第一台数字计算机出现于 20 世纪 40 年代末和 50 年代初，被发明并用于科学应用。当时的科学应用通常使用相对简单的数据结构，但需要大量的浮点算术计算。最常见的数据结构是数组和矩阵；最常见的控制结构是计数循环和选择。早期为科学应用发明的高级编程语言旨在满足这些需求。它们的竞争对手是汇编语言，因此效率是主要考虑因素。第一门科学应用语言是 Fortran。ALGOL 60 及其大多数后代也旨在用于这一领域，尽管它们也被设计用于相关领域。对于一些以效率为主要考虑因素的科学应用，例如 20 世纪 50 年代和 60 年代常见的应用，没有一种后续语言比 Fortran 更好，这也解释了为什么 Fortran 仍在使用。

The first digital computers, which appeared in the late 1940s and early 1950s, were invented and used for scientific applications. Typically, the scientific applications of that time used relatively simple data structures, but required large numbers of floating-point arithmetic computations. The most common data structures were arrays and matrices; the most common control structures were counting loops and selections. The early high-level programming languages invented for scientific applications were designed to provide for those needs. Their competition was assembly language, so efficiency was a primary concern. The first language for scientific applications was Fortran. ALGOL 60 and most of its descendants were also intended to be used in this area, although they were designed to be used in related areas as well. For some scientific applications where efficiency is the primary concern, such as those that were common in the 1950s and 1960s, no subsequent language is significantly better than Fortran, which explains why Fortran is still used.

计算机在商业领域的应用始于 20 世纪 50 年代。为此目的，人们开发了专用计算机和专用语言。第一个成功的商业高级语言是 COBOL（ISO/IEC，2002），其初始版本出现于 1960 年。它可能仍然是这些应用程序最常用的语言。商业语言的特点是能够生成复杂的报告，能够精确地描述和存储十进制数字和字符数据，并且能够指定十进制算术运算。

The use of computers for business applications began in the 1950s. Special computers were developed for this purpose, along with special languages. The first successful high-level language for business was COBOL (ISO/IEC, 2002), the initial version of which appeared in 1960. It probably still is the most commonly used language for these applications. Business languages are characterized by facilities for producing elaborate reports, precise ways of describing and storing decimal numbers and character data, and the ability to specify decimal arithmetic operations.

除了 COBOL 的发展和演进之外，商业应用语言的发展很少。因此，本书仅对 COBOL 中的结构进行了有限的讨论。

There have been few developments in business application languages outside the development and evolution of COBOL. Therefore, this book includes only limited discussions of the structures in COBOL.

人工智能 (AI) 是计算机应用的一个广泛领域，其特点是使用符号而不是数字计算。符号计算意味着操纵由名称而不是数字组成的符号。此外，使用数据链接列表而不是数组更方便地完成符号计算。这种编程有时需要比其他编程领域更大的灵活性。例如，在某些 AI 应用程序中，在执行期间创建和执行代码段的能力很方便。

Artificial intelligence (AI) is a broad area of computer applications characterized by the use of symbolic rather than numeric computations. Symbolic computation means that symbols, consisting of names rather than numbers, are manipulated. Also, symbolic computation is more conveniently done with linked lists of data rather than arrays. This kind of programming sometimes requires more flexibility than other programming domains. For example, in some AI applications the ability to create and execute code segments during execution is convenient.

第一个被广泛使用的为人工智能应用开发的编程语言是 1959 年出现的函数式语言 Lisp（McCarthy 等人，1965 年）。1990 年之前开发的大多数人工智能应用程序都是用 Lisp 或其近亲之一编写的。然而，在 20 世纪 70 年代初期，出现了一种针对其中一些应用程序的替代方法——使用 Prolog（Clocksin 和 Mellish，2013 年）语言进行逻辑编程。最近，一些人工智能应用程序是用 Python（Lutz，2013 年）等系统语言编写的。第 15章和第 16章分别介绍了 Lisp 的一种方言Scheme（Dybvig，2011 年）和 Prolog 。

The first widely used programming language developed for AI applications was the functional language Lisp (McCarthy et al., 1965), which appeared in 1959. Most AI applications developed prior to 1990 were written in Lisp or one of its close relatives. During the early 1970s, however, an alternative approach to some of these applications appeared—logic programming using the Prolog (Clocksin and Mellish, 2013) language. More recently, some AI applications have been written in systems languages such as Python (Lutz, 2013). Scheme (Dybvig, 2011), a dialect of Lisp, and Prolog are introduced in Chapters 15 and 16, respectively.

万维网由多种语言支持，从标记语言（如 HTML，它不是编程语言）到通用编程语言（如 Java）。由于对动态 Web 内容的普遍需求，内容呈现技术中通常包含一些计算能力。此功能可以通过在 HTML 文档中嵌入编程代码来提供。此类代码通常采用脚本语言的形式，例如 JavaScript（Flanagan，2011 年）或 PHP（Tatroe 等，2013 年）。还有一些标记类语言已扩展为包含控制文档处理的结构，这些语言将在第 1.5节和第 2章 中讨论。

The World Wide Web is supported by an eclectic collection of languages, ranging from markup languages, such as HTML, which is not a programming language, to general-purpose programming languages, such as Java. Because of the pervasive need for dynamic Web content, some computation capability is often included in the technology of content presentation. This functionality can be provided by embedding programming code in an HTML document. Such code is often in the form of a scripting language, such as JavaScript (Flanagan, 2011) or PHP (Tatroe et al., 2013). There are also some markup-like languages that have been extended to include constructs that control document processing, which are discussed in Section 1.5 and in Chapter 2.

评判编程语言最重要的标准之一是程序的易读性和易理解性。1970 年之前，软件开发主要被认为是编写代码。编程语言的一个积极特性是效率。语言结构更多地是从计算机的角度而不是计算机用户的角度设计的。然而，在 20 世纪 70 年代，软件生命周期概念（Booch，1987）得到了发展；编码被降级为一个较小的角色，而维护被认为是周期的主要部分，特别是在成本方面。因为维护的难易程度在很大程度上取决于程序的可读性，所以可读性成为程序和编程语言质量的重要标准。这是编程语言进化的一个重要转折点。从关注机器到关注人有一个明显的转变。

One of the most important criteria for judging a programming language is the ease with which programs can be read and understood. Before 1970, software development was largely thought of in terms of writing code. The primary positive characteristic of programming languages was efficiency. Language constructs were designed more from the point of view of the computer than of the computer users. In the 1970s, however, the software life-cycle concept (Booch, 1987) was developed; coding was relegated to a much smaller role, and maintenance was recognized as a major part of the cycle, particularly in terms of cost. Because ease of maintenance is determined in large part by the readability of programs, readability became an important measure of the quality of programs and programming languages. This was an important juncture in the evolution of programming languages. There was a distinct crossover from a focus on machine orientation to a focus on human orientation.

可读性必须结合问题领域来考虑。例如，如果一个描述计算的程序是用一种不适用于此类用途的语言编写的，那么该程序可能不自然且复杂，从而很难阅读。

Readability must be considered in the context of the problem domain. For example, if a program that describes a computation is written in a language not designed for such use, the program may be unnatural and convoluted, making it unusually difficult to read.

以下小节描述了有助于提高编程语言可读性的特征。

The following subsections describe characteristics that contribute to the readability of a programming language.

count = count + 1
count += 1
count++
++count

count = count + 1
count += 1
count++
++count

A Reg1, memory_cell 
AR Reg1, Reg2

A Reg1, memory_cell 
AR Reg1, Reg2

Reg1 ← contents(Reg1) + contents(memory_cell)
Reg1 ← contents(Reg1) + contents(Reg2)

Reg1 ← contents(Reg1) + contents(memory_cell)
Reg1 ← contents(Reg1) + contents(Reg2)

ADDL operand_1, operand_2

ADDL operand_1, operand_2

operand_2 ← contents(operand_1) + contents(operand_2)

operand_2 ← contents(operand_1) + contents(operand_2)

a + b

a + b

timeout = 1

timeout = 1

timeout = true 

timeout = true 

可写性是衡量语言用于为特定问题领域编写程序的难易程度的标准。影响可读性的大多数语言特性也会影响可写性。这直接源于这样一个事实：编写程序的过程要求程序员频繁地重读已经编写好的程序部分。

Writability is a measure of how easily a language can be used to create programs for a chosen problem domain. Most of the language characteristics that affect readability also affect writability. This follows directly from the fact that the process of writing a program requires the programmer frequently to reread the part of the program that is already written.

与可读性一样，可写性必须结合语言的目标问题领域来考虑。如果一种语言是为特定应用而设计的，而另一种语言不是，那么在特定应用领域比较两种语言的可写性显然是不公平的。例如，对于创建具有图形用户界面 (GUI) 的程序，Visual BASIC (VB) (Halvorson，2013) 和 C 的可写性存在巨大差异，VB 是理想的选择。对于编写系统程序（例如操作系统），它们的可写性也大不相同，而 C 是为操作系统而设计的。

As is the case with readability, writability must be considered in the context of the target problem domain of a language. It simply is not fair to compare the writability of two languages in the realm of a particular application when one was designed for that application and the other was not. For example, the writabilities of Visual BASIC (VB) (Halvorson, 2013) and C are dramatically different for creating a program that has a graphical user interface (GUI), for which VB is ideal. Their writabilities are also quite different for writing systems programs, such as an operating system, for which C was designed.

以下小节描述了影响语言可写性的最重要特征。

The following subsections describe the most important characteristics influencing the writability of a language.

如果一个程序在所有条件下都能按照其规范执行，则该程序被认为是可靠的。以下小节描述了几种对给定语言中程序的可靠性有重大影响的语言特性。

A program is said to be reliable if it performs to its specifications under all conditions. The following subsections describe several language features that have a significant effect on the reliability of programs in a given language.

编程语言的总成本取决于它的许多特性。

The total cost of a programming language is a function of many of its characteristics.

首先，培训程序员使用该语言需要花费成本，而这要取决于语言的简单性和正交性以及程序员的经验。虽然功能更强大的语言并不一定更难学习，但通常确实如此。

First, there is the cost of training programmers to use the language, which is a function of the simplicity and orthogonality of the language and the experience of the programmers. Although more powerful languages are not necessarily more difficult to learn, they often are.

其次，用该语言编写程序的成本较高。这是语言可写性的一个函数，在一定程度上取决于其目的与特定应用程序的接近程度。最初设计和实现高级语言的努力是出于降低软件开发成本的愿望。

Second, there is the cost of writing programs in the language. This is a function of the writability of the language, which depends in part on its closeness in purpose to the particular application. The original efforts to design and implement high-level languages were driven by the desire to lower the costs of creating software.

在良好的编程环境中，培训程序员的成本和用语言编写程序的成本都可以大大降低。编程环境将在第1.8节 中讨论。

Both the cost of training programmers and the cost of writing programs in a language can be significantly reduced in a good programming environment. Programming environments are discussed in Section 1.8.

第三，执行用某种语言编写的程序的成本在很大程度上受到该语言设计的影响。无论编译器的质量如何，需要进行大量运行时类型检查的语言都会阻碍代码的快速执行。虽然执行效率是早期语言设计中最重要的考虑因素，但现在人们认为它不那么重要了。

Third, the cost of executing programs written in a language is greatly influenced by that language’s design. A language that requires many run-time type checks will prohibit fast code execution, regardless of the quality of the compiler. Although execution efficiency was the foremost concern in the design of early languages, it is now considered to be less important.

可以在编译成本和编译代码的执行速度之间进行简单的权衡。优化是指编译器可能用来减小其生成的代码的大小和/或提高其执行速度的一系列技术。如果进行很少或没有进行优化，编译速度会比进行大量优化要快得多生成优化的代码。两种方案之间的选择受编译器使用环境的影响。在面向初学编程学生的实验室中，这些学生通常在开发过程中多次编译他们的程序，但执行时间却很少（他们的程序很小，而且只需正确执行一次），因此应该很少或根本不进行优化。在生产环境中，编译后的程序在开发后会多次执行，因此最好付出额外的成本来优化代码。

A simple trade-off can be made between compilation cost and execution speed of the compiled code. Optimization is the name given to the collection of techniques that compilers may use to decrease the size and/or increase the execution speed of the code they produce. If little or no optimization is done, compilation can be done much faster than if a significant effort is made to produce optimized code. The choice between the two alternatives is influenced by the environment in which the compiler will be used. In a laboratory for beginning programming students, who often compile their programs many times during development but use little execution time (their programs are small and they must execute correctly only once), little or no optimization should be done. In a production environment, where compiled programs are executed many times after development, it is better to pay the extra cost to optimize the code.

第四，可靠性差的成本很高。如果关键系统（如核电站或医用X光机）的软件出现故障，成本可能非常高。非关键系统出现故障，也可能造成未来业务损失或因软件系统缺陷而引发诉讼，成本也非常高昂。

Fourth, there is the cost of poor reliability. If the software fails in a critical system, such as a nuclear power plant or an X-ray machine for medical use, the cost could be very high. The failures of noncritical systems can also be very expensive in terms of lost future business or lawsuits over defective software systems.

最后要考虑的是维护程序的成本，包括更正和修改以添加新功能。软件维护的成本取决于多种语言特性，主要是可读性。由于维护通常由软件原作者以外的个人完成，因此可读性差会使任务极具挑战性。

The final consideration is the cost of maintaining programs, which includes both corrections and modifications to add new functionality. The cost of software maintenance depends on a number of language characteristics, primarily readability. Because maintenance is often done by individuals other than the original author of the software, poor readability can make the task extremely challenging.

软件可维护性的重要性怎么强调也不为过。据估计，对于寿命相对较长的大型软件系统，维护成本可能高达开发成本的两到四倍（Sommerville，2010）。

The importance of software maintainability cannot be overstated. It has been estimated that for large software systems with relatively long lifetimes, maintenance costs can be as high as two to four times as much as development costs (Sommerville, 2010).

在影响语言成本的所有因素中，最重要的三个是：程序开发、维护和可靠性。由于这三个因素是可写性和可读性的函数，因此这两个评估标准也是最重要的。

Of all the contributors to language costs, three are most important: program development, maintenance, and reliability. Because these are functions of writability and readability, these two evaluation criteria are, in turn, the most important.

当然，还有许多其他标准可用于评估编程语言。一个例子是可移植性，即程序从一种实现转移到另一种实现的难易程度。可移植性受语言标准化程度的影响最大。有些语言根本没有标准化，这使得用这些语言编写的程序很难从一种实现转移到另一种实现。在某些情况下，由于某些语言的实现现在只有单一来源，这一问题得到了缓解。标准化是一个耗时且困难的过程。一个委员会于 1989 年开始着手制定 C++ 的标准版本。该版本于 1998 年获得批准。

Of course, a number of other criteria could be used for evaluating programming languages. One example is portability, or the ease with which programs can be moved from one implementation to another. Portability is most strongly influenced by the degree of standardization of the language. Some languages are not standardized at all, making programs in these languages very difficult to move from one implementation to another. This problem is alleviated in some cases by the fact that implementations for some languages now have single sources. Standardization is a time-consuming and difficult process. A committee began work on producing a standard version of C++ in 1989. It was approved in 1998.

通用性（适用于广泛的应用）和明确性（语言官方定义文档的完整性和精确性）是另外两个标准。

Generality (the applicability to a wide range of applications) and well-definedness (the completeness and precision of the language’s official defining document) are two other criteria.

大多数标准，特别是可读性、可写性和可靠性，既没有精确的定义，也无法准确衡量。尽管如此，它们仍然是有用的概念，为编程语言的设计和评估提供了宝贵的见解。

Most criteria, particularly readability, writability, and reliability, are neither precisely defined nor accurately measurable. Nevertheless, they are useful concepts and they provide valuable insight into the design and evaluation of programming languages.

关于评估标准的最后一点说明：语言设计标准从不同的角度有不同的权重。语言实现者关心的是主要在于语言结构和特性的实现难度。语言使用者首先担心可写性，其次才是可读性。语言设计者则倾向于强调优雅性和吸引广泛使用的能力。这些特征经常相互冲突。

A final note on evaluation criteria: language design criteria are weighed differently from different perspectives. Language implementors are concerned primarily with the difficulty of implementing the constructs and features of the language. Language users are worried about writability first and readability later. Language designers are likely to emphasize elegance and the ability to attract widespread use. These characteristics often conflict with one another.

计算机的基本架构对语言设计产生了深远的影响。过去 60 年来，大多数流行语言都是围绕当时流行的计算机架构设计的，这种架构称为冯·诺依曼架构，以其创始人之一约翰·冯·诺依曼（发音为“von Noyman”）的名字命名。这些语言被称为命令式语言。在冯·诺依曼计算机中，数据和程序都存储在同一内存中。执行指令的中央处理器 (CPU) 与内存是分开的。因此，指令和数据必须从内存传输或通过管道传输到 CPU。CPU 中的运算结果必须移回内存。自 20 世纪 40 年代以来，几乎所有数字计算机都是基于冯·诺依曼架构的。冯·诺依曼计算机的整体结构如图1.1 所示。

The basic architecture of computers has had a profound effect on language design. Most of the popular languages of the past 60 years have been designed around the prevalent computer architecture, called the von Neumann architecture, after one of its originators, John von Neumann (pronounced “von Noyman”). These languages are called imperative languages. In a von Neumann computer, both data and programs are stored in the same memory. The central processing unit (CPU), which executes instructions, is separate from the memory. Therefore, instructions and data must be transmitted, or piped, from memory to the CPU. Results of operations in the CPU must be moved back to memory. Nearly all digital computers built since the 1940s have been based on the von Neumann architecture. The overall structure of a von Neumann computer is shown in Figure 1.1.

图1.1冯·诺依曼计算机体系结构

Figure 1.1 The von Neumann computer architecture

由于冯·诺依曼体系结构，命令式语言的核心特征是变量（它模拟内存单元）、赋值语句（它基于管道操作）和迭代形式的重复（这是在此体系结构上实现重复的最有效方法）。表达式中的操作数从内存管道传输到 CPU，而表达式的求值结果则通过管道传输回赋值左侧所表示的内存单元。冯·诺依曼计算机上的迭代速度很快，因为指令存储在内存的相邻单元中，并且重复执行一段代码只需要一个分支指令。这种效率不鼓励使用递归进行重复，尽管递归有时更自然。

Because of the von Neumann architecture, the central features of imperative languages are variables, which model the memory cells; assignment statements, which are based on the piping operation; and the iterative form of repetition, which is the most efficient way to implement repetition on this architecture. Operands in expressions are piped from memory to the CPU, and the result of evaluating the expression is piped back to the memory cell represented by the left side of the assignment. Iteration is fast on von Neumann computers because instructions are stored in adjacent cells of memory and repeating the execution of a section of code requires only a branch instruction. This efficiency discourages the use of recursion for repetition, although recursion is sometimes more natural.

在冯·诺依曼架构计算机上，机器代码程序的执行发生在一个称为提取-执行周期的过程中。如前所述，程序驻留在内存中，但在 CPU 中执行。每个要执行的指令都必须从内存移动到处理器。下一个要执行的指令的地址保存在称为程序计数器的寄存器中。提取-执行周期可以简单地通过以下算法描述：

The execution of a machine code program on a von Neumann architecture computer occurs in a process called the fetch-execute cycle. As stated earlier, programs reside in memory but are executed in the CPU. Each instruction to be executed must be moved from memory to the processor. The address of the next instruction to be executed is maintained in a register called the program counter. The fetch-execute cycle can be simply described by the following algorithm:

• 初始化程序计数器

• initialize the program counter

• repeat永远

• repeat forever

•   获取程序计数器指向的指令

•   fetch the instruction pointed to by the program counter

•   增加程序计数器以指向下一条指令

•   increment the program counter to point at the next instruction

•   解码指令

•   decode the instruction

•   执行指令

•   execute the instruction

• end repeat

• end repeat

算法中的“解码指令”步骤意味着检查指令以确定其指定的操作。当遇到停止指令时，程序执行终止，尽管在实际计算机上很少执行停止指令。相反，控制权从操作系统转移到用户程序以供其执行，然后在用户程序执行完成时返回操作系统。在计算机系统中，内存中可能同时存在多个用户程序，这个过程要复杂得多。

The “decode the instruction” step in the algorithm means the instruction is examined to determine what action it specifies. Program execution terminates when a stop instruction is encountered, although on an actual computer a stop instruction is rarely executed. Rather, control transfers from the operating system to a user program for its execution and then back to the operating system when the user program execution is complete. In a computer system in which more than one user program may be in memory at a given time, this process is far more complex.

如前所述，函数式语言或应用性语言是一种以将函数应用于给定参数为主要计算手段的语言。使用函数式语言进行编程时，无需使用命令式语言中使用的变量、赋值语句和迭代。尽管许多计算机科学家已经阐述了诸如 Scheme 之类的函数式语言的诸多优势，但它们不太可能取代命令式语言，除非设计出能够高效执行函数式语言程序的非冯·诺依曼计算机。在对此表示哀叹的人中，最有说服力的可能是Fortran 原版首席设计师John Backus (1978) 。

As stated earlier, a functional, or applicative, language is one in which the primary means of computation is applying functions to given parameters. Programming can be done in a functional language without the kind of variables that are used in imperative languages, without assignment statements, and without iteration. Although many computer scientists have expounded on the myriad benefits of functional languages, such as Scheme, it is unlikely that they will displace the imperative languages until a non–von Neumann computer is designed that allows efficient execution of programs in functional languages. Among those who have bemoaned this fact, perhaps the most eloquent was John Backus (1978), the principal designer of the original version of Fortran.

尽管命令式编程语言的结构是基于机器架构而不是编程语言使用者的能力和倾向而建立的，但有些人认为使用命令式语言比使用函数式语言更自然。因此，这些人认为，即使函数式程序与命令式程序一样高效，命令式编程语言的使用仍将占主导地位。

In spite of the fact that the structure of imperative programming languages is modeled on a machine architecture, rather than on the abilities and inclinations of the users of programming languages, some believe that using imperative languages is somehow more natural than using a functional language. So, these people believe that even if functional programs were as efficient as imperative programs, the use of imperative programming languages would still dominate.

20 世纪 60 年代末和 70 年代初，由结构化编程运动发起的对软件开发过程和编程语言设计的深入分析。

The late 1960s and early 1970s brought an intense analysis, begun in large part by the structured-programming movement, of both the software development process and programming language design.

进行这项研究的一个重要原因是，随着硬件成本下降和程序员成本上升，计算的主要成本从硬件转移到了软件。程序员生产力的提高相对较小。此外，计算机正在解决越来越大、越来越复杂的问题。与 20 世纪 60 年代初期一样，计算机只是简单地求解方程组来模拟卫星轨迹，而现在，人们开始为大型复杂任务编写程序，例如控制大型石油精炼设施和提供全球航空预订系统。

An important reason for this research was the shift in the major cost of computing from hardware to software, as hardware costs decreased and programmer costs increased. Increases in programmer productivity were relatively small. In addition, progressively larger and more complex problems were being solved by computers. Rather than simply solving sets of equations to simulate satellite tracks, as in the early 1960s, programs were being written for large and complex tasks, such as controlling large petroleum-refining facilities and providing worldwide airline reservation systems.

20 世纪 70 年代研究的成果是出现了新的软件开发方法，即自顶向下设计和逐步细化。发现的编程语言主要缺陷是类型检查不完整和控制语句不足（需要大量使用 goto）。

The new software development methodologies that emerged as a result of the research of the 1970s were called top-down design and stepwise refinement. The primary programming language deficiencies that were discovered were incompleteness of type checking and inadequacy of control statements (requiring the extensive use of gotos).

20 世纪 70 年代末，程序设计方法开始从面向过程转向面向数据。简单来说，面向数据的方法强调数据设计，注重使用抽象数据类型来解决问题。

In the late 1970s, a shift from procedure-oriented to data-oriented program design methodologies began. Simply put, data-oriented methods emphasize data design, focusing on the use of abstract data types to solve problems.

为了在软件系统设计中有效地使用数据抽象，它必须得到用于实现的语言的支持。第一个提供有限数据抽象支持的语言是 SIMULA 67（Birtwistle 等人，1973 年），尽管该语言当然不是因为它而流行起来的。直到 20 世纪 70 年代初，数据抽象的好处才得到广泛认可。然而，自 20 世纪 70 年代末以来设计的大多数语言都支持数据抽象，第 11章 将对此进行详细讨论。

For data abstraction to be used effectively in software system design, it must be supported by the languages used for implementation. The first language to provide even limited support for data abstraction was SIMULA 67 (Birtwistle et al., 1973), although that language certainly was not propelled to popularity because of it. The benefits of data abstraction were not widely recognized until the early 1970s. However, most languages designed since the late 1970s support data abstraction, which is discussed in detail in Chapter 11.

面向数据软件开发演进的最新一步始于 20 世纪 80 年代初，即面向对象设计。面向对象方法始于数据抽象，它用数据对象封装处理并控制对数据的访问，并添加了继承和动态方法绑定。继承是一个强大的概念，它大大增强了现有软件的潜在重用性，从而提供了显著提高软件开发效率的可能性。这是面向对象语言越来越流行的一个重要因素。动态（运行时）方法绑定允许更灵活地使用继承。

The latest step in the evolution of data-oriented software development, which began in the early 1980s, is object-oriented design. Object-oriented methodology begins with data abstraction, which encapsulates processing with data objects and controls access to data, and adds inheritance and dynamic method binding. Inheritance is a powerful concept that greatly enhances the potential reuse of existing software, thereby providing the possibility of significant increases in software development productivity. This is an important factor in the increase in popularity of object-oriented languages. Dynamic (run-time) method binding allows more flexible use of inheritance.

面向对象编程与支持其概念的语言 Smalltalk（Goldberg 和 Robson，1989 年）一起发展起来。尽管 Smalltalk 从未像许多其他语言那样得到广泛使用，但面向对象编程的支持现已成为大多数流行命令式语言的一部分，包括 Java、C++ 和 C#。面向对象概念也已应用于 CLOS（Bobrow 等人，1988 年）和 F#（Syme 等人，2010 年）中的函数式编程，以及 Prolog++（Moss，1994 年）中的逻辑编程。第12章 将详细讨论面向对象编程的语言支持。

Object-oriented programming developed along with a language that supported its concepts: Smalltalk (Goldberg and Robson, 1989). Although Smalltalk never became as widely used as many other languages, support for object-oriented programming is now part of most popular imperative languages, including Java, C++, and C#. Object-oriented concepts have also found their way into functional programming in CLOS (Bobrow et al., 1988) and F# (Syme et al., 2010), as well as logic programming in Prolog++ (Moss, 1994). Language support for object-oriented programming is discussed in detail in Chapter 12.

从某种意义上说，面向过程编程与面向数据编程相反。尽管面向数据的方法现在主导着软件开发，但面向过程的方法并没有被抛弃。相反，近年来，在面向过程编程方面出现了大量研究，特别是在并发领域。这些研究工作带来了对用于创建和控制并发程序单元的语言功能的需求。Java 和 C# 就具备这样的功能。第13章 将详细讨论并发。

Procedure-oriented programming is, in a sense, the opposite of data-oriented programming. Although data-oriented methods now dominate software development, procedure-oriented methods have not been abandoned. On the contrary, in recent years, a good deal of research has occurred in procedure-oriented programming, especially in the area of concurrency. These research efforts brought with them the need for language facilities for creating and controlling concurrent program units. Java and C# include such capabilities. Concurrency is discussed in detail in Chapter 13.

软件开发方法中的所有这些进化步骤都导致了支持它们的新语言结构的出现。

All of these evolutionary steps in software development methodologies led to new language constructs to support them.

编程语言可以通过三种通用方法中的任何一种来实现。一种极端方法是将程序翻译成机器语言，然后直接在计算机上执行。这种方法称为编译器实现，其优点是一旦翻译过程完成，程序执行速度非常快。大多数语言（如 C、COBOL 和 C++）的生产实现都是通过编译器实现的。

Programming languages can be implemented by any of three general methods. At one extreme, programs can be translated into machine language, which can be executed directly on the computer. This method is called a compiler implementation and has the advantage of very fast program execution, once the translation process is complete. Most production implementations of languages, such as C, COBOL, and C++, are by compilers.

编译器翻译的语言称为源语言。编译和程序执行的过程分为几个阶段，其中最重要的阶段如图1.3 所示。

The language that a compiler translates is called the source language. The process of compilation and program execution takes place in several phases, the most important of which are shown in Figure 1.3.

图1.3编译过程

Figure 1.3 The compilation process

词法分析器将源程序的字符集中到词法单元中。程序的词法单元包括标识符、特殊词、运算符和标点符号。词法分析器会忽略源程序中的注释，因为编译器不需要它们。

The lexical analyzer gathers the characters of the source program into lexical units. The lexical units of a program are identifiers, special words, operators, and punctuation symbols. The lexical analyzer ignores comments in the source program because the compiler has no use for them.

语法分析器从词法分析器中获取词汇单元，并使用它们构建层次结构，称为解析树。这些解析树代表程序的语法结构。在许多情况下，并没有构建实际的解析树结构；相反，构建解析树所需的信息构建树是直接生成并使用的。词汇单元和解析树将在第 3章中进一步讨论。词汇分析和语法分析或解析将在第 4章 中讨论。

The syntax analyzer takes the lexical units from the lexical analyzer and uses them to construct hierarchical structures called parse trees. These parse trees represent the syntactic structure of the program. In many cases, no actual parse tree structure is constructed; rather, the information that would be required to build a tree is generated and used directly. Both lexical units and parse trees are discussed further in Chapter 3. Lexical analysis and syntax analysis, or parsing, are discussed in Chapter 4.

中间代码生成器生成另一种语言的程序，该程序处于源程序和编译器的最终输出（机器语言程序）之间的中间级别。4中间语言有时看起来很像汇编语言，事实上，有时是真正的汇编语言。在其他情况下，中间代码的级别略高于汇编语言。语义分析器是中间代码生成器的一个组成部分。语义分析器检查在语法分析期间很难（甚至不可能）检测到的错误（例如类型错误）。

The intermediate code generator produces a program in a different language, at an intermediate level between the source program and the final output of the compiler: the machine language program.4 Intermediate languages sometimes look very much like assembly languages, and in fact, sometimes are actual assembly languages. In other cases, the intermediate code is at a level somewhat higher than an assembly language. The semantic analyzer is an integral part of the intermediate code generator. The semantic analyzer checks for errors, such as type errors, that are difficult, if not impossible, to detect during syntax analysis.

优化，通过使程序更小或更快（或两者兼而有之）来改进程序（通常是中间代码版本）。由于许多优化很难在机器语言上进行，因此大多数优化都是在中间代码上进行的。

Optimization, which improves programs (usually in their intermediate code version) by making them smaller or faster or both. Because many kinds of optimization are difficult to do on machine language, most optimization is done on the intermediate code.

代码生成器将程序的优化中间代码版本翻译成等效的机器语言程序。

The code generator translates the optimized intermediate code version of the program into an equivalent machine language program.

符号表是编译过程的数据库。符号表的主要内容是程序中每个用户定义名称的类型和属性信息。这些信息由词法和语法分析器放在符号表中，并由语义分析器和代码生成器使用。

The symbol table serves as a database for the compilation process. The primary contents of the symbol table are the type and attribute information of each user-defined name in the program. This information is placed in the symbol table by the lexical and syntax analyzers and is used by the semantic analyzer and the code generator.

如前所述，虽然编译器生成的机器语言可以直接在硬件上执行，但它几乎总是必须与其他代码一起运行。大多数用户程序还需要操作系统中的程序。其中最常见的是输入和输出程序。当用户程序需要所需的系统程序时，编译器会构建对它们进行的调用。在执行编译器生成的机器语言程序之前，必须先找到操作系统中所需的程序并将其链接到用户程序。链接操作通过将系统程序入口点的地址放在用户程序中对它们的调用中，将用户程序连接到系统程序。用户代码和系统代码有时合称为加载模块或可执行映像。收集系统程序并将其链接到用户程序的过程称为链接和加载，有时简称为链接。它由称为链接器的系统程序完成。

As stated previously, although the machine language generated by a compiler can be executed directly on the hardware, it must nearly always be run along with some other code. Most user programs also require programs from the operating system. Among the most common of these are programs for input and output. The compiler builds calls to required system programs when they are needed by the user program. Before the machine language programs produced by a compiler can be executed, the required programs from the operating system must be found and linked to the user program. The linking operation connects the user program to the system programs by placing the addresses of the entry points of the system programs in the calls to them in the user program. The user and system code together are sometimes called a load module, or executable image. The process of collecting system programs and linking them to user programs is called linking and loading, or sometimes just linking. It is accomplished by a systems program called a linker.

除了系统程序之外，用户程序通常必须链接到库中先前编译的程序。因此，链接器不仅将给定程序链接到系统程序，还可以将其链接到其他用户或系统提供的程序。

In addition to systems programs, user programs must often be linked to previously compiled programs that reside in libraries. So the linker not only links a given program to system programs, but also it may link it to other user or system-supplied programs.

计算机内存和处理器之间的连接速度通常决定了计算机的速度，因为指令的执行速度通常比移动到处理器执行的速度更快。这种连接被称为冯·诺依曼瓶颈，它是冯·诺依曼结构计算机速度的主要限制因素。冯·诺依曼瓶颈一直是并行计算机研究和开发的主要动机之一。

The speed of the connection between a computer’s memory and its processor often determines the speed of the computer, because instructions often can be executed faster than they can be moved to the processor for execution. This connection is called the von Neumann bottleneck; it is the primary limiting factor in the speed of von Neumann architecture computers. The von Neumann bottleneck has been one of the primary motivations for the research and development of parallel computers.

在所有实现方法中，纯解释与编译截然相反。在这种方法中，程序由另一个称为解释器的程序解释，不进行任何翻译。解释器程序充当机器的软件模拟，其提取-执行周期处理高级语言程序语句而不是机器指令。这种软件模拟显然为该语言提供了一个虚拟机。

Pure interpretation lies at the opposite end (from compilation) among implementation methods. With this approach, programs are interpreted by another program called an interpreter, with no translation whatever. The interpreter program acts as a software simulation of a machine whose fetch-execute cycle deals with high-level language program statements rather than machine instructions. This software simulation obviously provides a virtual machine for the language.

纯解释的优点是可以轻松实现许多源代码级调试操作，因为所有运行时错误消息都可以引用源代码级单元。例如，如果发现数组索引超出范围，则错误消息可以轻松指出错误的源代码行和数组的名称。另一方面，这种方法有一个严重的缺点，即执行速度比编译系统慢 10 到 100 倍。这种缓慢的主要原因是高级语言语句的解码，这些语句比机器语言指令复杂得多（尽管语句的数量可能比等效机器代码中的指令少）。此外，无论语句执行多少次，每次都必须对其进行解码。因此，语句解码，而不是处理器和内存之间的连接，是纯解释器的瓶颈。

Pure interpretation has the advantage of allowing easy implementation of many source-level debugging operations, because all run-time error messages can refer to source-level units. For example, if an array index is found to be out of range, the error message can easily indicate the source line of the error and the name of the array. On the other hand, this method has the serious disadvantage that execution is 10 to 100 times slower than in compiled systems. The primary source of this slowness is the decoding of the high-level language statements, which are far more complex than machine language instructions (although there may be fewer statements than instructions in equivalent machine code). Furthermore, regardless of how many times a statement is executed, it must be decoded every time. Therefore, statement decoding, rather than the connection between the processor and memory, is the bottleneck of a pure interpreter.

纯解释的另一个缺点是它通常需要更多空间。除了源程序之外，符号表在解释期间也必须存在。此外，源程序可能以易于访问和修改的形式存储，而不是以提供最小尺寸的形式存储。

Another disadvantage of pure interpretation is that it often requires more space. In addition to the source program, the symbol table must be present during interpretation. Furthermore, the source program may be stored in a form designed for easy access and modification rather than one that provides for minimal size.

尽管 20 世纪 60 年代的一些简单的早期语言（APL、SNOBOL（Griswold 等，1971）和 Lisp）是纯解释型的，但到了 20 世纪 80 年代，这种方法很少用于高级语言。然而，近年来，纯解释型语言在一些 Web 脚本语言（如 JavaScript 和 PHP）中卷土重来，如今这些语言已得到广泛应用。纯解释型语言的流程如图1.4 所示。

Although some simple early languages of the 1960s (APL, SNOBOL (Griswold et al., 1971), and Lisp) were purely interpreted, by the 1980s, the approach was rarely used on high-level languages. However, in recent years, pure interpretation has made a significant comeback with some Web scripting languages, such as JavaScript and PHP, which are now widely used. The process of pure interpretation is shown in Figure 1.4.

有些语言实现系统是编译器和纯解释器之间的折衷；它们将高级语言程序翻译成易于解释的中间语言。这种方法比纯解释更快，因为源语言语句只需解码一次。这种实现称为混合实现系统。

Some language implementation systems are a compromise between compilers and pure interpreters; they translate high-level language programs to an intermediate language designed to allow easy interpretation. This method is faster than pure interpretation because the source language statements are decoded only once. Such implementations are called hybrid implementation systems.

混合实现系统所采用的流程如图 1.5所示。它不将中间语言代码翻译成机器代码，而是简单地解释中间代码。

The process used in a hybrid implementation system is shown in Figure 1.5. Instead of translating intermediate language code to machine code, it simply interprets the intermediate code.

图1.5混合实施体系

Figure 1.5 Hybrid implementation system

Perl 采用混合系统实现，Perl 程序经过部分编译，在解释之前检测错误，并简化解释器。

Perl is implemented with a hybrid system. Perl programs are partially compiled to detect errors before interpretation and to simplify the interpreter.

Java 的最初实现都是混合的。它的中间形式称为字节码，它为任何具有字节码解释器和相关运行时系统的机器提供了可移植性。这些统称为 Java 虚拟机。现在有系统将 Java 字节码转换为机器码，以便更快地执行。

Initial implementations of Java were all hybrid. Its intermediate form, called byte code, provides portability to any machine that has a byte code interpreter and an associated run-time system. Together, these are called the Java Virtual Machine. There are now systems that translate Java byte code into machine code for faster execution.

即时 (JIT) 实现系统首先将程序翻译成中间语言。然后在执行期间，当中间语言方法被调用时，它会将其编译为机器代码。机器代码版本将保留以供后续调用。JIT 系统现在广泛用于 Java 程序。此外，.NET 语言都使用 JIT 系统实现。

A Just-in-Time (JIT) implementation system initially translates programs to an intermediate language. Then, during execution, it compiles intermediate language methods into machine code when they are called. The machine code version is kept for subsequent calls. JIT systems now are widely used for Java programs. Also, the .NET languages are all implemented with a JIT system.

有时，实现者可能会为一种语言提供编译和解释两种实现。在这些情况下，解释器用于开发和调试程序。然后，在达到（相对）无错误状态后，对程序进行编译以提高其执行速度。

Sometimes an implementor may provide both compiled and interpreted implementations for a language. In these cases, the interpreter is used to develop and debug programs. Then, after a (relatively) bug-free state is reached, the programs are compiled to increase their execution speed.

预处理器是一种在程序编译之前处理程序的程序。预处理器指令嵌入在程序中。预处理器本质上是一个宏扩展器。预处理器指令通常用于指定要包含来自另一个文件的代码。例如，C 预处理器指令

A preprocessor is a program that processes a program just before the program is compiled. Preprocessor instructions are embedded in programs. The preprocessor is essentially a macro expander. Preprocessor instructions are commonly used to specify that the code from another file is to be included. For example, the C preprocessor instruction

#include "myLib.h"

#include "myLib.h"

导致预处理器将 的内容复制myLib.h到程序中的 位置#include。

causes the preprocessor to copy the contents of myLib.h into the program at the position of the #include.

其他预处理指令用于定义表示表达式的符号。例如，可以使用

Other preprocessor instructions are used to define symbols to represent expressions. For example, one could use

#define max(A, B) ((A) > (B) ? (A) : (B))

#define max(A, B) ((A) > (B) ? (A) : (B))

确定两个给定表达式中的最大者。例如，表达式

to determine the largest of two given expressions. For example, the expression

x = max(2 * y, z / 1.73);

x = max(2 * y, z / 1.73);

将被预处理器扩展为

would be expanded by the preprocessor to

x = ((2 * y) > (z / 1.73) ? (2 * y) : (z / 1.73);

x = ((2 * y) > (z / 1.73) ? (2 * y) : (z / 1.73);

请注意，这是表达式副作用可能导致麻烦的情况之一。例如，如果提供给宏的任一表达式max具有副作用（例如z++），则可能会导致问题。由于两个表达式参数中的一个被求值两次，因此这可能导致z宏扩展生成的代码将其递增两次。

Notice that this is one of those cases where expression side effects can cause trouble. For example, if either of the expressions given to the max macro have side effects—such as z++—it could cause a problem. Because one of the two expression parameters is evaluated twice, this could result in z being incremented twice by the code produced by the macro expansion.

1936 年至 1945 年间，德国科学家康拉德·楚泽 (Konrad Zuse，发音为“Tsoo-zuh”) 用机电继电器制造了一系列复杂精密的计算机。到 1945 年初，盟军轰炸摧毁了他最新的型号 Z4 中除一台之外的所有计算机，因此他搬到了巴伐利亚州的一个偏远村庄欣特施泰因，他的研究小组成员也各奔东西。

Between 1936 and 1945, German scientist Konrad Zuse (pronounced “Tsoo-zuh”) built a series of complex and sophisticated computers from electromechanical relays. By early 1945, Allied bombing had destroyed all but one of his latest models, the Z4, so he moved to a remote Bavarian village, Hinterstein, and his research group members went their separate ways.

独自一人，祖泽开始努力开发一种用于表达 Z4 计算的语言，这是他 1943 年作为博士论文提案开始的一项项目。他将这种语言命名为 Plankalkül，意思是程序演算。在一份 1945 年但直到 1972 年才发表的长篇手稿中（祖泽，1972 年），祖泽定义了 Plankalkül，并用该语言编写了算法来解决各种各样的问题。

Working alone, Zuse embarked on an effort to develop a language for expressing computations for the Z4, a project he had begun in 1943 as a proposal for his Ph.D. dissertation. He named this language Plankalkül, which means program calculus. In a lengthy manuscript dated 1945 but not published until 1972 (Zuse, 1972), Zuse defined Plankalkül and wrote algorithms in the language to solve a wide variety of problems.

Plankalkül 非常完整，在数据结构方面具有一些最先进的功能。Plankalkül 中最简单的数据类型是单个位。整数和浮点数值类型都是从位类型构建的。浮点类型使用二进制补码表示法和当前使用的“隐藏位”方案，以避免存储浮点值规范化小数部分的最高有效位。

Plankalkül was remarkably complete, with some of its most advanced features in the area of data structures. The simplest data type in Plankalkül was the single bit. Integer and floating-point numeric types were built from the bit type. The floating-point type used twos-complement notation and the “hidden bit” scheme currently used to avoid storing the most significant bit of the normalized fraction part of a floating-point value.

除了常见的标量类型外，Plankalkül 还包含数组和记录（在基于 C 的语言中称为结构）。记录可以包括嵌套记录。

In addition to the usual scalar types, Plankalkül included arrays and records (called structs in the C-based languages). The records could include nested records.

尽管该语言没有明确的 goto，但它确实包含一个类似于 Ada 的迭代语句for。它还具有Fin带上标的命令，该命令指定退出给定数量的迭代循环嵌套或开始新的迭代循环。Plankalkül 包含一个选择语句，但不允许使用子句else。

Although the language had no explicit goto, it did include an iterative statement similar to the Ada for. It also had the command Fin with a superscript that specified an exit out of a given number of iteration loop nestings or to the beginning of a new iteration cycle. Plankalkül included a selection statement, but it did not allow an else clause.

Zuse 程序最有趣的特性之一是包含数学表达式，显示程序变量之间的当前关系。这些表达式说明了在代码中出现它们时执行时会发生什么。这些与 Java 的断言以及公理语义中的断言非常相似，这将在第3章 中讨论。

One of the most interesting features of Zuse’s programs was the inclusion of mathematical expressions showing the current relationships between program variables. These expressions stated what would be true during execution at the points in the code where they appeared. These are very similar to the assertions of Java and in those in axiomatic semantics, which is discussed in Chapter 3.

Zuse 的手稿中包含的程序比 1945 年之前编写的任何程序都要复杂得多。其中包括对数字数组进行排序的程序；测试给定图的连通性；执行整数和浮点运算（包括平方根）；以及对具有六个不同优先级的括号和运算符的逻辑公式进行语法分析。也许最引人注目的是他 49 页的国际象棋算法，而他并不是这项游戏的专家。

Zuse’s manuscript contained programs of far greater complexity than any written prior to 1945. Included were programs to sort arrays of numbers; test the connectivity of a given graph; carry out integer and floating-point operations, including square root; and perform syntax analysis on logic formulas that had parentheses and operators in six different levels of precedence. Perhaps most remarkable were his 49 pages of algorithms for playing chess, a game in which he was not an expert.

如果计算机科学家在 20 世纪 50 年代早期发现了 Zuse 对 Plankalkül 的描述，那么阻碍该语言按定义实现的唯一因素就是符号。每个语句由两行或三行代码组成。第一行最像当前语言的语句。第二行是可选的，包含第一行中数组引用的下标。19 世纪中叶，查尔斯·巴贝奇 (Charles Babbage) 在他的分析机程序中使用了相同的指示下标的方法。每个 Plankalkül 语句的最后一行包含第一行中提到的变量的类型名称。初次看到这种符号时，您会感到十分害怕。

If a computer scientist had found Zuse’s description of Plankalkül in the early 1950s, the single aspect of the language that would have hindered its implementation as defined would have been the notation. Each statement consisted of either two or three lines of code. The first line was most like the statements of current languages. The second line, which was optional, contained the subscripts of the array references in the first line. The same method of indicating subscripts was used by Charles Babbage in programs for his Analytical Engine in the middle of the nineteenth century. The last line of each Plankalkül statement contained the type names for the variables mentioned in the first line. This notation is quite intimidating when first seen.

以下示例赋值语句将表达式的值赋给A[4} + 1，A[5]说明了此表示法。 标有 的行表示V下标，标有 的行S表示数据类型。在此示例中，表示n1.n位整数：

The following example assignment statement, which assigns the value of the expression A[4} + 1 to A[5], illustrates this notation. The row labeled V is for subscripts, and the row labeled S is for the data types. In this example, 1.n means an integer of n bits:

  | A + 1 => A
V | 4        5
S | 1.n      1.n

  | A + 1 => A
V | 4        5
S | 1.n      1.n

我们只能推测，如果楚泽的工作在 1945 年甚至 1950 年就已广为人知，编程语言设计可能会朝什么方向发展。同样有趣的是，如果他在一个有其他科学家包围的和平环境中完成这项工作，而不是在 1945 年在德国几乎与世隔绝的情况下完成工作，他的工作可能会有何不同。

We can only speculate on the direction that programming language design might have taken if Zuse’s work had been widely known in 1945 or even 1950. It is also interesting to consider how his work might have been different had he done it in a peaceful environment surrounded by other scientists, rather than in Germany in 1945 in virtual isolation.

第一种新语言名为短代码，由 John Mauchly 于 1949 年为 BINAC 计算机开发，BINAC 是最早成功的存储程序电子计算机之一。短代码后来被转移到 UNIVAC I 计算机（美国销售的第一台商用电子计算机），并且多年来一直是编程这些机器的主要手段之一。尽管人们对原始短代码知之甚少，因为其完整描述从未发表过，但 UNIVAC I 版本的编程手册确实留存了下来（Remington-Rand，1952 年）。可以肯定这两个版本非常相似。

The first of these new languages, named Short Code, was developed by John Mauchly in 1949 for the BINAC computer, which was one of the first successful stored-program electronic computers. Short Code was later transferred to a UNIVAC I computer (the first commercial electronic computer sold in the United States) and, for several years, was one of the primary means of programming those machines. Although little is known of the original Short Code because its complete description was never published, a programming manual for the UNIVAC I version did survive (Remington-Rand, 1952). It is safe to assume that the two versions were very similar.

UNIVAC I 内存的字有 72 位，分为 12 个六位字节。短代码由要评估的数学表达式的编码版本组成。代码是字节对值，许多方程式可以编码在一个字中。包括以下操作代码：

The words of the UNIVAC I’s memory had 72 bits, grouped as 12 six-bit bytes. Short Code consisted of coded versions of mathematical expressions that were to be evaluated. The codes were byte-pair values, and many equations could be coded in a word. The following operation codes were included:

01 -  06 abs value     1n (n+2)nd power
02 )  07 +             2n (n+2)nd root
03 =  08 pause         4n if <= n
04 /  09 (             58 print and tab

01 -  06 abs value     1n (n+2)nd power
02 )  07 +             2n (n+2)nd root
03 =  08 pause         4n if <= n
04 /  09 (             58 print and tab

变量以字节对代码命名，用作常量的位置也是如此。例如，X0和Y0可以是变量。语句

Variables were named with byte-pair codes, as were locations to be used as constants. For example, X0 and Y0 could be variables. The statement

X0 = SQRT(ABS(Y0))

X0 = SQRT(ABS(Y0))

在单词中编码为00 X0 03 20 06 Y0。首字母00用作填充以填充单词。有趣的是，没有乘法代码；乘法是通过简单地将两个操作数放在一起来表示的，就像在代数中一样。

would be coded in a word as 00 X0 03 20 06 Y0. The initial 00 was used as padding to fill the word. Interestingly, there was no multiplication code; multiplication was indicated by simply placing the two operands next to each other, as in algebra.

短代码没有被翻译成机器码，而是用纯解释器实现的。当时这个过程被称为自动编程。它显然简化了编程过程，但却以执行时间为代价。短代码解释速度比机器码慢约 50 倍。

Short Code was not translated to machine code; rather, it was implemented with a pure interpreter. At the time, this process was called automatic programming. It clearly simplified the programming process, but at the expense of execution time. Short Code interpretation was approximately 50 times slower than machine code.

在其他地方，正在开发的解释系统将机器语言扩展为包含浮点运算。John Backus 为 IBM 701 开发的 Speedcoding 系统就是这样的系统的一个示例 ( Backus, 1954 )。Speedcoding 解释器有效地将 701 转换为虚拟的三地址浮点计算器。该系统包括对浮点数据的四种算术运算以及平方根、正弦、反正切、指数和对数等运算的伪指令。条件和无条件分支以及输入/输出转换也是虚拟架构的一部分。为了了解此类系统的局限性，请考虑加载解释器后剩余的可用内存只有 700 个字，并且加法指令需要 4.2 毫秒才能执行。另一方面，Speedcoding 包括自动递增地址寄存器的新颖功能。直到 1962 年的 UNIVAC 1107 计算机，这种功能才出现在硬件中。由于这些功能，矩阵乘法可以在 12 条 Speedcoding 指令中完成。Backus 声称，用机器代码编程需要两周时间才能解决的问题，使用 Speedcoding 只需几个小时即可解决。

In other places, interpretive systems were being developed that extended machine languages to include floating-point operations. The Speedcoding system developed by John Backus for the IBM 701 is an example of such a system (Backus, 1954). The Speedcoding interpreter effectively converted the 701 to a virtual three-address floating-point calculator. The system included pseudoinstructions for the four arithmetic operations on floating-point data, as well as operations such as square root, sine, arc tangent, exponent, and logarithm. Conditional and unconditional branches and input/output conversions were also part of the virtual architecture. To get an idea of the limitations of such systems, consider that the remaining usable memory after loading the interpreter was only 700 words and that the add instruction took 4.2 milliseconds to execute. On the other hand, Speedcoding included the novel facility of automatically incrementing address registers. This facility did not appear in hardware until the UNIVAC 1107 computers of 1962. Because of such features, matrix multiplication could be done in 12 Speedcoding instructions. Backus claimed that problems that could take two weeks to program in machine code could be programmed in a few hours using Speedcoding.

1951 年至 1953 年间，UNIVAC 的 Grace Hopper 领导的团队开发了一系列名为 A-0、A-1 和 A-2 的“编译”系统，这些系统将伪代码扩展为机器代码子程序，就像将宏扩展为汇编语言一样。这些“编译器”的伪代码源代码仍然非常原始，尽管这比机器代码有了很大的改进，因为它使源程序变得更短。Wilkes (1952)独立提出了类似的过程。

Between 1951 and 1953, a team led by Grace Hopper at UNIVAC developed a series of “compiling” systems named A-0, A-1, and A-2 that expanded a pseudocode into machine code subprograms in the same way as macros are expanded into assembly language. The pseudocode source for these “compilers” was still quite primitive, although even this was a great improvement over machine code because it made source programs much shorter. Wilkes (1952) independently suggested a similar process.

大约在同一时间，人们还开发了其他简化编程任务的方法。在剑桥大学，David J. Wheeler（1950 年）开发了一种使用可重定位地址块的方法，至少部分解决了绝对寻址问题，后来，Maurice V. Wilkes（也在剑桥大学）扩展了这个想法，设计了一种可以组合选定子程序并分配存储的汇编程序（Wilkes 等人，1951 年、1957 年）。这确实是一项重要而根本的进步。

Other means of easing the task of programming were being developed at about the same time. At Cambridge University, David J. Wheeler (1950) developed a method of using blocks of relocatable addresses to solve, at least partially, the problem of absolute addressing, and later, Maurice V. Wilkes (also at Cambridge) extended the idea to design an assembly program that could combine chosen subroutines and allocate storage (Wilkes et al., 1951, 1957). This was indeed an important and fundamental advance.

我们还应该提到，汇编语言与上述的伪代码有很大不同，它是在 20 世纪 50 年代早期发展起来的。然而，它们对高级语言的设计影响不大。

We should also mention that assembly languages, which are quite different from the pseudocodes discussed, evolved during the early 1950s. However, they had little impact on the design of high-level languages.

从 20 世纪 40 年代末到 50 年代中期，人们之所以容忍解释系统速度缓慢，主要原因之一是当时的计算机缺乏浮点硬件。所有浮点运算都必须在软件中模拟，这是一个非常耗时的过程。由于软件浮点处理花费了如此多的处理器时间，解释的开销和索引的模拟相对来说微不足道。只要浮点必须由软件完成，解释就是可以接受的开销。然而，当时的许多程序员从未使用过解释系统，他们更喜欢手工编码的机器（或汇编）语言的效率。IBM 704 系统的发布，在硬件中同时具有索引和浮点指令，预示着解释时代的结束，至少对于科学计算而言是如此。浮点硬件的加入消除了解释成本的隐藏之处。

One of the primary reasons why the slowness of interpretive systems was tolerated from the late 1940s to the mid-1950s was the lack of floating-point hardware in the available computers. All floating-point operations had to be simulated in software, a very time-consuming process. Because so much processor time was spent in software floating-point processing, the overhead of interpretation and the simulation of indexing were relatively insignificant. As long as floating-point had to be done by software, interpretation was an acceptable expense. However, many programmers of that time never used interpretive systems, preferring the efficiency of hand-coded machine (or assembly) language. The announcement of the IBM 704 system, with both indexing and floating-point instructions in hardware, heralded the end of the interpretive era, at least for scientific computation. The inclusion of floating-point hardware removed the hiding place for the cost of interpretation.

尽管 Fortran 通常被认为是第一个编译型高级语言，但谁应该为第一个此类语言的实现而受到赞誉却一直没有定论。Knuth和 Pardo (1977)将曼彻斯特 Mark I 计算机的 Autocode 编译器的功劳归功于 Alick E. Glennie。Glennie 在英国皇家军备研究机构 Fort Halstead 开发了该编译器。该编译器于 1952 年 9 月投入使用。然而，根据 John Backus ( Wexelblat, 1981 , p. 26) 的说法，Glennie 的 Autocode 级别太低且面向机器，因此不应被视为编译系统。Backus 将功劳归功于麻省理工学院的 Laning 和 Zierler。

Although Fortran is often credited with being the first compiled high-level language, the question of who deserves credit for implementing the first such language is somewhat open. Knuth and Pardo (1977) give the credit to Alick E. Glennie for his Autocode compiler for the Manchester Mark I computer. Glennie developed the compiler at Fort Halstead, Royal Armaments Research Establishment, in England. The compiler was operational by September 1952. However, according to John Backus (Wexelblat, 1981, p. 26), Glennie’s Autocode was so low level and machine oriented that it should not be considered a compiled system. Backus gives the credit to Laning and Zierler at the Massachusetts Institute of Technology.

Laning 和 Zierler 系统（Laning and Zierler, 1954）是第一个实现的代数翻译系统。我们所说的代数是指它可以翻译算术表达式，使用单独编码的子程序来计算超越函数（例如正弦和对数），并包含数组。 1952 年夏天，该系统以实验原型形式在 MIT Whirlwind 计算机上实现，并于 1953 年 5 月以更易用的形式实现。翻译器生成一个子程序调用来编码程序中的每个公式或表达式。源语言易于阅读，唯一实际包含的机器指令是用于分支的指令。尽管这项工作早于 Fortran 的工作，但它从未离开过 MIT。

The Laning and Zierler system (Laning and Zierler, 1954) was the first algebraic translation system to be implemented. By algebraic, we mean that it translated arithmetic expressions, used separately coded subprograms to compute transcendental functions (e.g., sine and logarithm), and included arrays. The system was implemented on the MIT Whirlwind computer, in experimental prototype form, in the summer of 1952 and in a more usable form by May 1953. The translator generated a subroutine call to code each formula, or expression, in the program. The source language was easy to read, and the only actual machine instructions included were for branching. Although this work preceded the work on Fortran, it never escaped MIT.

尽管有这些早期作品，但第一个被广泛接受的编译高级语言是 Fortran。以下小节记述了这一重要发展。

In spite of these earlier works, the first widely accepted compiled high-level language was Fortran. The following subsections chronicle this important development.

早在 1954 年 5 月宣布 704 系统之前，Fortran 的计划就已开始。到 1954 年 11 月，IBM 的 John Backus 和他的团队已经撰写了一份题为“IBM 数学公式翻译系统：FORTRAN”的报告（IBM，1954 年）。该文档描述了 Fortran 的第一个版本，我们称之为 Fortran 0，该版本尚未实施。它还大胆地指出，Fortran 将提供手工编码程序的效率和解释性伪代码系统的编程简易性。在另一股乐观情绪中，该文档指出 Fortran 将消除编码错误和调试过程。基于这一前提，第一个 Fortran 编译器几乎不包含语法错误检查。

Even before the 704 system was announced in May 1954, plans were begun for Fortran. By November 1954, John Backus and his group at IBM had produced the report titled “The IBM Mathematical FORmula TRANslating System: FORTRAN” (IBM, 1954). This document described the first version of Fortran, which we refer to as Fortran 0, prior to its implementation. It also boldly stated that Fortran would provide the efficiency of hand-coded programs and the ease of programming of the interpretive pseudocode systems. In another burst of optimism, the document stated that Fortran would eliminate coding errors and the debugging process. Based on this premise, the first Fortran compiler included little syntax error checking.

Fortran 的开发环境如下：(1) 计算机内存小、速度慢且相对不可靠；(2) 计算机主要用于科学计算；(3) 当时没有有效的计算机编程方法；(4) 由于计算机成本高于程序员的成本，因此生成目标代码的速度是第一批 Fortran 编译器的主要目标。Fortran 早期版本的特点直接源于这种环境。

The environment in which Fortran was developed was as follows: (1) Computers had small memories and were slow and relatively unreliable; (2) the primary use of computers was for scientific computations; (3) there were no existing efficient and effective ways to program computers; and (4) because of the high cost of computers compared to the cost of programmers, speed of the generated object code was the primary goal of the first Fortran compilers. The characteristics of the early versions of Fortran follow directly from this environment.

Fortran 0 在实施期间进行了修改，实施期始于 1955 年 1 月，一直持续到 1957 年 4 月编译器发布。实施后的语言我们称之为 Fortran I，在 1956 年 10 月出版的第一本 Fortran程序员参考手册中有所描述（IBM，1956 年）。Fortran I 包括输入/​​输出格式、最多六个字符的变量名（Fortran 0 中只有两个字符）、用户定义的子例程，尽管它们无法单独编译If选择语句和Do循环语句。

Fortran 0 was modified during the implementation period, which began in January 1955 and continued until the release of the compiler in April 1957. The implemented language, which we call Fortran I, is described in the first Fortran Programmer’s Reference Manual, published in October 1956 (IBM, 1956). Fortran I included input/output formatting, variable names of up to six characters (it had been just two in Fortran 0), user-defined subroutines, although they could not be separately compiled, the If selection statement, and the Do loop statement.

Fortran I 的所有控制语句均基于 704 指令。尚不清楚 704 设计者是否指定了 Fortran I 的控制语句设计，还是 Fortran I 设计者向 704 设计者建议了这些指令。

All of Fortran I’s control statements were based on 704 instructions. It is not clear whether the 704 designers dictated the control statement design of Fortran I or whether the designers of Fortran I suggested these instructions to the 704 designers.

Fortran I 语言中没有数据类型声明。变量名以I、J、K、和开头的变量隐式为整数类型，其他所有变量隐式为浮点数。选择这些字母作为此约定是基于这样一个事实：当时科学家和工程师使用字母作为变量下标，通常是Li 、 j和k 。Fortran的设计者们慷慨地添加了三个额外的字母。MN

There were no data-typing statements in the Fortran I language. Variables whose names began with I, J, K, L, M, and N were implicitly integer type, and all others were implicitly floating-point. The choice of the letters for this convention was based on the fact that at that time scientists and engineers used letters as variable subscripts, usually i, j, and k. In a gesture of generosity, Fortran’s designers threw in the three additional letters.

Fortran 开发小组在设计该语言时最大胆的宣称是，编译器生成的机器代码效率只有手工生成的代码的一半。1这比其他任何事情都更让潜在用户心存疑虑，并在 Fortran 实际发布之前阻止了人们对其产生很大兴趣。然而，令几乎所有人都感到惊讶的是，Fortran 开发小组几乎实现了其效率目标。构建第一个编译器所花费的 18 个工作年中，大部分精力都花在了优化上，结果非常有效。

The most audacious claim made by the Fortran development group during the design of the language was that the machine code produced by the compiler would be about half as efficient as what could be produced by hand.1 This, more than anything else, made skeptics of potential users and prevented a great deal of interest in Fortran before its actual release. To almost everyone’s surprise, however, the Fortran development group nearly achieved its goal in efficiency. The largest part of the 18 worker-years of effort used to construct the first compiler had been spent on optimization, and the results were remarkably effective.

1958 年 4 月的一项调查结果显示了 Fortran 的早期成功。当时，大约一半为 704 编写的代码都是用 Fortran 编写的，尽管仅仅一年前大多数编程界还对此持怀疑态度。

The early success of Fortran is shown by the results of a survey made in April 1958. At that time, roughly half of the code being written for 704s was being written in Fortran, in spite of the skepticism of most of the programming world only a year earlier.

Fortran II 编译器于 1958 年春季发布。它修复了 Fortran I 编译系统中的许多错误，并为该语言添加了一些重要特性，其中最重要的是子程序的独立编译。如果没有独立编译，程序中的任何更改都需要重新编译整个程序。Fortran I 缺乏独立编译能力，再加上 704 的可靠性较差，导致程序长度实际上限制在 300 到 400 行左右（Wexelblat，1981 年，第 68 页）。较长的程序在机器发生故障之前很难被完全编译。包含子程序的预编译机器语言版本的能力大大缩短了编译过程，并使开发更大的程序变得切实可行。

The Fortran II compiler was distributed in the spring of 1958. It fixed many of the bugs in the Fortran I compilation system and added some significant features to the language, the most important being the independent compilation of subroutines. Without independent compilation, any change in a program required that the entire program be recompiled. Fortran I’s lack of independent-compilation capability, coupled with the poor reliability of the 704, placed a practical restriction on the length of programs to about 300 to 400 lines (Wexelblat, 1981, p. 68). Longer programs had a poor chance of being compiled completely before a machine failure occurred. The capability of including precompiled machine language versions of subprograms shortened the compilation process considerably and made it practical to develop much larger programs.

Fortran III 已经开发出来，但从未广泛传播。然而，Fortran IV 成为当时使用最广泛的编程语言之一。它在 1960 年至 1962 年间不断发展，并被标准化为 Fortran 66（ANSI，1966），尽管这个名字很少使用。Fortran IV 在许多方面都比 Fortran II 有所改进。其中最重要的新增功能包括变量的显式类型声明、逻辑构造If以及将子程序作为参数传递给其他子程序的能力。

A Fortran III was developed, but it was never widely distributed. Fortran IV, however, became one of the most widely used programming languages of its time. It evolved over the period 1960 to 1962 and was standardized as Fortran 66 (ANSI, 1966), although that name was rarely used. Fortran IV was an improvement over Fortran II in many ways. Among its most important additions were explicit type declarations for variables, a logical If construct, and the capability of passing subprograms as parameters to other subprograms.

Fortran IV 被 Fortran 77 取代，后者于 1978 年成为新标准 ( ANSI, 1978a )。Fortran 77 保留了 Fortran IV 的大部分功能，并添加了字符串处理、逻辑循环控制语句和If带有可选Else子句的功能。

Fortran IV was replaced by Fortran 77, which became the new standard in 1978 (ANSI, 1978a). Fortran 77 retained most of the features of Fortran IV and added character string handling, logical loop control statements, and an If with an optional Else clause.

Fortran 90（ANSI，1992）与 Fortran 77 有很大不同。最显著的新增功能是动态数组、记录、指针、多选语句和模块。此外，Fortran 90 子程序可以递归调用。

Fortran 90 (ANSI, 1992) was dramatically different from Fortran 77. The most significant additions were dynamic arrays, records, pointers, a multiple selection statement, and modules. In addition, Fortran 90 subprograms could be recursively called.

Fortran 90 定义中包含的一个新概念是删除早期版本的一些语言功能。虽然 Fortran 90 包含了 Fortran 77 的所有功能，但语言定义中包含了一份建议在下一版语言中删除的构造列表。

A new concept that was included in the Fortran 90 definition was that of removing some language features from earlier versions. While Fortran 90 included all of the features of Fortran 77, the language definition included a list of constructs that were recommended for removal in the next version of the language.

Fortran 90 包含两个简单的语法变化，它们改变了程序的外观和描述该语言的文献。首先，删除了代码所需的固定格式，即要求对语句的特定部分使用特定的字符位置。例如，语句标签只能出现在前五个位置，语句不能在第七个位置之前开始。这种严格的代码格式是围绕打孔卡的使用而设计的。第二个变化是 FORTRAN 的官方拼写变为 Fortran。这一变化伴随着 Fortran 程序中关键字和标识符全部使用大写字母的惯例的变化。新的惯例是只有关键字和标识符的第一个字母才大写。

Fortran 90 included two simple syntactic changes that altered the appearance of both programs and the literature describing the language. First, the required fixed format of code, which required the use of specific character positions for specific parts of statements, was dropped. For example, statement labels could appear only in the first five positions and statements could not begin before the seventh position. This rigid formatting of code was designed around the use of punch cards. The second change was that the official spelling of FORTRAN became Fortran. This change was accompanied by the change in convention of using all uppercase letters for keywords and identifiers in Fortran programs. The new convention was that only the first letter of keywords and identifiers would be uppercase.

Fortran 95 ( INCITS/ISO/IEC, 1997 ) 继续了语言的演进，但只做了少量改动。除其他改动外，还Forall添加了新的迭代结构，以简化 Fortran 程序的并行化任务。

Fortran 95 (INCITS/ISO/IEC, 1997) continued the evolution of the language, but only a few changes were made. Among other things, a new iteration construct, Forall, was added to ease the task of parallelizing Fortran programs.

Fortran 2003（Metcalf 等人，2004）增加了对面向对象编程、参数化派生类型、过程指针以及与 C 编程语言互操作性的支持。

Fortran 2003 (Metcalf et al., 2004) added support for object-oriented programming, parameterized derived types, procedure pointers, and interoperability with the C programming language.

Fortran 的最新版本 Fortran 2008 (ISO/IEC 1539-1, 2010) 增加了对块的支持，用于定义本地范围、共同数组（提供并行执行模型）和构造DO CONCURRENT（用于指定无相互依赖性的循环）。新版本 Fortran 2015 正在开发中，计划于 2018 年发布。

The latest version of Fortran, Fortran 2008 (ISO/IEC 1539-1, 2010), added support for blocks to define local scopes, co-arrays, which provide a parallel execution model, and the DO CONCURRENT construct, to specify loops without interdependencies. A new version, Fortran 2015, is under development and is scheduled for release in 2018.

Fortran 的最初设计团队认为语言设计只是设计翻译器这一关键任务的必要前提。此外，他们从未想到 Fortran 会用在非IBM 制造。然而，他们被迫考虑为其他 IBM 机器构建 Fortran 编译器，因为 704 的后继产品 709 是在 704 Fortran 编译器发布之前发布的。Fortran 对计算机使用的影响，以及所有后续编程语言都归功于 Fortran 这一事实，鉴于其设计者的谦虚目标，确实令人印象深刻。

The original Fortran design team thought of language design only as a necessary prelude to the critical task of designing the translator. Furthermore, it never occurred to them that Fortran would be used on computers not manufactured by IBM. However, they were forced to consider building Fortran compilers for other IBM machines only because the successor to the 704, the 709, was announced before the 704 Fortran compiler was released. The effect that Fortran has had on the use of computers, along with the fact that all subsequent programming languages owe a debt to Fortran, is indeed impressive in light of the modest goals of its designers.

Fortran I 及其 90 年代之前的所有后续版本都具有一个可高度优化编译器的功能，即所有变量的类型和存储都是在运行前固定的。在执行期间不能分配任何新变量或空间。这牺牲了灵活性，换来了简单性和效率。它消除了递归子程序的可能性，并且很难实现动态增长或改变形状的数据结构。当然，在开发早期版本的 Fortran 时所构建的程序类型主要是数字性质的，与最近的软件项目相比很简单。因此，牺牲并不大。

One of the features of Fortran I, and all of its successors before 90, that allows highly optimizing compilers was that the types and storage for all variables are fixed before run time. No new variables or space could be allocated during execution. This was a sacrifice of flexibility to simplicity and efficiency. It eliminated the possibility of recursive subprograms and made it difficult to implement data structures that grow or change shape dynamically. Of course, the kinds of programs that were being built at the time of the development of the early versions of Fortran were primarily numerical in nature and were simple in comparison with more recent software projects. Therefore, the sacrifice was not a great one.

Fortran 的整体成功是无可厚非的：它极大地改变了计算机的使用方式。当然，这在很大程度上是因为它是第一种广泛使用的高级语言。与后来开发的概念和语言相比，Fortran 的早期版本在很多方面都存在不足，这是意料之中的。毕竟，将 1910 款福特 T 型车的性能和舒适度与 2017 款福特野马的性能和舒适度进行比较是不公平的。尽管如此，尽管 Fortran 存在不足之处，但对 Fortran 软件的巨额投资势头以及其他因素使其得以使用 60 年。

The overall success of Fortran is difficult to overstate: It dramatically changed the way computers are used. This is, of course, in large part due to its being the first widely used high-level language. In comparison with concepts and languages developed later, early versions of Fortran suffer in a variety of ways, as should be expected. After all, it would not be fair to compare the performance and comfort of a 1910 Model T Ford with the performance and comfort of a 2017 Ford Mustang. Nevertheless, in spite of the inadequacies of Fortran, the momentum of the huge investment in Fortran software, among other factors, has kept it in use for 60 years.

ALGOL 60 的设计者之一 Alan Perlis 于 1978 年这样评价 Fortran：“Fortran 是计算机世界的通用语言。它是真正意义上的街头语言，而不是妓女的语言。它已经生存下来并将继续生存下去，因为它已经成为一种非常重要的商业活动中极其有用的一部分”（Wexelblat，1981 年，第 161 页）。

Alan Perlis, one of the designers of ALGOL 60, said of Fortran in 1978, “Fortran is the lingua franca of the computing world. It is the language of the streets in the best sense of the word, not in the prostitutional sense of the word. And it has survived and will survive because it has turned out to be a remarkably useful part of a very vital commerce” (Wexelblat, 1981, p. 161).

以下是 Fortran 95 程序的示例：

The following is an example of a Fortran 95 program:

! Fortran 95 Example program
!  Input:   An integer, List_Len, where List_Len is less
!           than 100, followed by List_Len-Integer values
!  Output:  The number of input values that are greater
!           than the average of all input values
Implicit none
Integer Dimension(99) :: Int_List
Integer :: List_Len, Counter, Sum, Average, Result
Result= 0
Sum = 0
Read *, List_Len
If ((List_Len > 0) .AND. (List_Len < 100)) Then
! Read input data into an array and compute its sum
   Do Counter = 1, List_Len
      Read *, Int_List(Counter)
      Sum = Sum + Int_List(Counter)
   End Do
! Compute the average
   Average = Sum / List_Len
! Count the values that are greater than the average
   Do Counter = 1, List_Len
      If (Int_List(Counter) > Average) Then
           Result = Result + 1
      End If
   End Do
! Print the result
   Print *, 'Number of values > Average is:', Result
Else
   Print *, 'Error - list length value is not legal'
End If
End Program Example

! Fortran 95 Example program
!  Input:   An integer, List_Len, where List_Len is less
!           than 100, followed by List_Len-Integer values
!  Output:  The number of input values that are greater
!           than the average of all input values
Implicit none
Integer Dimension(99) :: Int_List
Integer :: List_Len, Counter, Sum, Average, Result
Result= 0
Sum = 0
Read *, List_Len
If ((List_Len > 0) .AND. (List_Len < 100)) Then
! Read input data into an array and compute its sum
   Do Counter = 1, List_Len
      Read *, Int_List(Counter)
      Sum = Sum + Int_List(Counter)
   End Do
! Compute the average
   Average = Sum / List_Len
! Count the values that are greater than the average
   Do Counter = 1, List_Len
      If (Int_List(Counter) > Average) Then
           Result = Result + 1
      End If
   End Do
! Print the result
   Print *, 'Number of values > Average is:', Result
Else
   Print *, 'Error - list length value is not legal'
End If
End Program Example

20 世纪 50 年代中期，许多地方都开始对人工智能产生兴趣。这些兴趣有的来自语言学，有的来自心理学，还有的来自数学。语言学家关注自然语言处理。心理学家对人类信息存储和检索的建模以及大脑的其他基本过程感兴趣。数学家对某些智能过程的机械化感兴趣，例如定理证明。所有这些研究都得出了相同的结论：必须开发某种方法，让计算机能够处理链接列表中的符号数据。当时，几乎所有计算都是针对数组中的数字数据进行的。

Interest in AI appeared in the mid-1950s in a number of places. Some of this interest grew out of linguistics, some from psychology, and some from mathematics. Linguists were concerned with natural language processing. Psychologists were interested in modeling human information storage and retrieval, as well as other fundamental processes of the brain. Mathematicians were interested in mechanizing certain intelligent processes, such as theorem proving. All of these investigations arrived at the same conclusion: Some method must be developed to allow computers to process symbolic data in linked lists. At the time, nearly all computation was on numeric data in arrays.

列表处理的概念是由 RAND 公司的 Allen Newell、JC Shaw 和 Herbert Simon 开发的。它首次发表在一篇经典论文中，该论文描述了最早的 AI 程序之一 Logic Theorist2以及一种可以实现它的语言（Newell 和 Simon，1956 年）。该语言名为 IPL-I（信息处理语言 I），从未实现过。下一个版本 IPL-II 在 RAND Johnniac 计算机上实现。IPL 的开发一直持续到 1960 年，当时发表了 IPL-V 的描述（Newell 和 Tonge，1960 年）。IPL 语言的低级别阻碍了它们的广泛使用。它们实际上是用于假想计算机的汇编语言，通过解释器实现，其中包括列表处理指令。阻碍 IPL 语言流行的另一个因素是它们在鲜为人知的 Johnniac 机器上的实现。

The concept of list processing was developed by Allen Newell, J. C. Shaw, and Herbert Simon at the RAND Corporation. It was first published in a classic paper that describes one of the first AI programs, the Logic Theorist,2 and a language in which it could be implemented (Newell and Simon, 1956). The language, named IPL-I (Information Processing Language I), was never implemented. The next version, IPL-II, was implemented on a RAND Johnniac computer. Development of IPL continued until 1960, when the description of IPL-V was published (Newell and Tonge, 1960). The low level of the IPL languages prevented their widespread use. They were actually assembly languages for a hypothetical computer, implemented with an interpreter, in which list-processing instructions were included. Another factor that kept the IPL languages from becoming popular was their implementation on the obscure Johnniac machine.

IPL 语言的贡献在于它们的列表设计以及它们证明列表处理是可行且有用的。

The contributions of the IPL languages were in their list design and their demonstration that list processing was feasible and useful.

IBM 在 20 世纪 50 年代中期开始对人工智能产生兴趣，并选择定理证明作为示范领域。当时，Fortran 项目仍在进行中。Fortran I 编译器的高昂成本使 IBM 确信他们的列表处理应该附加到 Fortran，而不是以新语言的形式出现。因此，Fortran 列表处理语言 (FLPL) 被设计和实现为 Fortran 的扩展。FLPL 被用于构建平面几何的定理证明器，这当时被认为是机械定理证明最简单的领域。

IBM became interested in AI in the mid-1950s and chose theorem proving as a demonstration area. At the time, the Fortran project was still underway. The high cost of the Fortran I compiler convinced IBM that their list processing should be attached to Fortran, rather than in the form of a new language. Thus, the Fortran list processing language (FLPL) was designed and implemented as an extension to Fortran. FLPL was used to construct a theorem prover for plane geometry, which was then considered the easiest area for mechanical theorem proving.

1958 年，麻省理工学院的 John McCarthy 在 IBM 信息研究部获得了一个暑期职位。他暑期的目标是研究符号计算并制定一套进行此类计算的要求。作为一个试点示例问题领域，他选择了代数表达式的微分。这项研究得出了一系列语言要求。其中包括数学函数的控制流方法：递归和条件表达式。当时唯一可用的高级语言 Fortran I 都没有这些。

John McCarthy of MIT took a summer position at the IBM Information Research Department in 1958. His goal for the summer was to investigate symbolic computations and to develop a set of requirements for doing such computations. As a pilot example problem area, he chose differentiation of algebraic expressions. From this study came a list of language requirements. Among them were the control flow methods of mathematical functions: recursion and conditional expressions. The only available high-level language of the time, Fortran I, had neither of these.

符号微分研究的另一个需求是需要动态分配链接列表和某种隐式释放废弃列表。麦卡锡根本不会允许他的优雅微分算法充斥着显式释放语句。

Another requirement that grew from the symbolic-differentiation investigation was the need for dynamically allocated linked lists and some kind of implicit deallocation of abandoned lists. McCarthy simply would not allow his elegant algorithm for differentiation to be cluttered with explicit deallocation statements.

由于 FLPL 不支持递归、条件表达式、动态存储分配或隐式释放，因此 McCarthy 很清楚需要一种新的语言。

Because FLPL did not support recursion, conditional expressions, dynamic storage allocation, or implicit deallocation, it was clear to McCarthy that a new language was needed.

1958 年秋天，麦卡锡回到麻省理工学院后，他和马文·明斯基在麻省理工学院电子研究实验室的资助下成立了麻省理工学院人工智能项目。该项目的第一项重要工作是开发一个用于列表处理的软件系统。它最初用于实现麦卡锡提出的一个名为 Advice Taker 的程序。3这个应用程序成为开发列表处理语言 Lisp 的动力。Lisp 的第一个版本有时被称为“纯 Lisp”，因为它是一种纯函数式语言。在下一节中，我们将描述纯 Lisp 的开发。

When McCarthy returned to MIT in the fall of 1958, he and Marvin Minsky formed the MIT AI Project, with funding from the Research Laboratory for Electronics at MIT. The first important effort of the project was to produce a software system for list processing. It was to be used initially to implement a program proposed by McCarthy called the Advice Taker.3 This application became the impetus for the development of the list-processing language Lisp. The first version of Lisp is sometimes called “pure Lisp” because it is a purely functional language. In the following section, we describe the development of pure Lisp.

四分之一世纪以来，Lisp 完全主宰了人工智能应用。Lisp 效率低下的名声已不复存在。许多当代实现都经过编译，生成的代码比在解释器上运行源代码要快得多。除了在人工智能领域的成功之外，Lisp 还开创了函数式编程，这已被证明是编程语言中一个活跃的研究领域。如第1章 所述，许多编程语言研究人员认为，与使用命令式语言的过程式编程相比，函数式编程是一种更好的软件开发方法。

Lisp completely dominated AI applications for a quarter century. Much of the cause of Lisp’s reputation for being highly inefficient has been eliminated. Many contemporary implementations are compiled, and the resulting code is much faster than running the source code on an interpreter. In addition to its success in AI, Lisp pioneered functional programming, which has proven to be a lively area of research in programming languages. As stated in Chapter 1, many programming language researchers believe functional programming is a much better approach to software development than procedural programming using imperative languages.

以下是一个 Lisp 程序的示例：

The following is an example of a Lisp program:

; Lisp Example function
; The following code defines a Lisp predicate function
; that takes two lists as arguments and returns True
; if the two lists are equal, and NIL (false) otherwise
  (DEFUN equal_lists (lis1 lis2)
   (COND
     ((ATOM lis1) (EQ lis1 lis2))
     ((ATOM lis2) NIL)
     ((equal_lists (CAR lis1) (CAR lis2))
                   (equal_lists (CDR lis1) (CDR lis2)))
     (T NIL)
   )
)

; Lisp Example function
; The following code defines a Lisp predicate function
; that takes two lists as arguments and returns True
; if the two lists are equal, and NIL (false) otherwise
  (DEFUN equal_lists (lis1 lis2)
   (COND
     ((ATOM lis1) (EQ lis1 lis2))
     ((ATOM lis2) NIL)
     ((equal_lists (CAR lis1) (CAR lis2))
                   (equal_lists (CDR lis1) (CDR lis2)))
     (T NIL)
   )
)

目前，Lisp 的两种方言被广泛使用，即 Scheme 和 Common Lisp。以下小节将简要讨论它们。

Two dialects of Lisp are now widely used, Scheme and Common Lisp. These are briefly discussed in the following subsections.

ML（Meta Language ；Ullman，1998）最初由爱丁堡大学的 Robin Milner 于 20 世纪 80 年代设计，作为可计算函数逻辑（LCF；Milner 等人，1997 ）程序验证系统的元语言。ML 主要是一种函数式语言，但它也支持命令式编程。与 Lisp 和 Scheme 不同，ML 中每个变量和表达式的类型都可以在编译时确定。类型与对象而不是名称相关联。名称和表达式的类型是从其上下文推断出来的。

ML (MetaLanguage; Ullman, 1998) was originally designed in the 1980s by Robin Milner at the University of Edinburgh as a metalanguage for a program verification system named Logic for Computable Functions (LCF; Milner et al., 1997). ML is primarily a functional language, but it also supports imperative programming. Unlike Lisp and Scheme, the type of every variable and expression in ML can be determined at compile time. Types are associated with objects rather than names. Types of names and expressions are inferred from their context.

与 Lisp 和 Scheme 不同，ML 不使用源自 lambda 表达式的带括号函数语法。相反，ML 的语法类似于 Java 和 C++ 等命令式语言的语法。

Unlike Lisp and Scheme, ML does not use the parenthesized functional syntax that originated with lambda expressions. Rather, the syntax of ML resembles that of the imperative languages, such as Java and C++.

Miranda 是由英国坎特伯雷肯特大学的David Turner (1986)于 20 世纪 80 年代初开发的。Miranda 部分基于 ML、SASL 和 KRC 语言。Haskell ( Hudak and Fasel，1992 ) 很大程度上基于 Miranda。与 Miranda 一样，它是一种纯函数式语言，没有变量和赋值语句。Haskell 的另一个显著特征是使用惰性求值。这意味着在需要表达式的值之前不会对其进行求值。这导致该语言具有一些令人惊讶的功能。

Miranda was developed by David Turner (1986) at the University of Kent in Canterbury, England, in the early 1980s. Miranda is based partly on the languages ML, SASL, and KRC. Haskell (Hudak and Fasel, 1992) is based in large part on Miranda. Like Miranda, it is a purely functional language, having no variables and no assignment statement. Another distinguishing characteristic of Haskell is its use of lazy evaluation. This means that no expression is evaluated until its value is required. This leads to some surprising capabilities in the language.

Caml（Cousineau 等人，1998 年）及其支持面向对象编程的方言 OCaml（Smith，2006 年），源自 ML 和 Haskell。最后，F# 是一种相对较新的类型语言，直接基于 OCaml。F#（Syme 等人，2010 年）是一种 .NET 语言，可直接访问整个 .NET 库。作为一种 .NET 语言，它还意味着它可以与任何其他 .NET 语言顺利地进行互操作。F# 支持函数式编程和过程式编程。它还完全支持面向对象编程。

Caml (Cousineau et al., 1998) and its dialect that supports object-oriented programming, OCaml (Smith, 2006), descended from ML and Haskell. Finally, F# is a relatively new typed language based directly on OCaml. F# (Syme et al., 2010) is a .NET language with direct access to the whole .NET library. Being a .NET language also means it can smoothly interoperate with any other .NET language. F# supports both functional programming and procedural programming. It also fully supports object-oriented programming.

第15章 将进一步讨论 ML、Haskell 和 F# 。

ML, Haskell, and F# are further discussed in Chapter 15.

ALGOL 60 是设计用于科学应用的通用编程语言的努力的成果。到 1954 年底，Laning 和 Zierler 代数系统已经运行了一年多，并且发表了第一份关于 Fortran 的报告。Fortran 于 1957 年成为现实，并且正在开发其他几种高级语言。其中最引人注目的是卡内基理工学院的 Alan Perlis 设计的 IT，以及两种用于 UNIVAC 计算机的语言 MATH-MATIC 和 UNICODE。语言的激增使得用户之间的程序共享变得困难。此外，新语言都是围绕单一架构发展起来的，一些用于 UNIVAC 计算机，一些用于 IBM 700 系列机器。为了应对这种机器相关语言的蓬勃发展，美国几家大型计算机用户团体，包括 SHARE（IBM 科学用户团体）和 USE（UNIVAC Scientific Exchange，大型 UNIVAC 科学用户团体），于 1957 年 5 月 10 日向计算机协会 (ACM) 提交了一份请愿书，要求成立一个委员会来研究并建议采取行动创建一种独立于机器的科学编程语言。尽管 Fortran 可能是一种候选语言，但它无法成为一种通用语言，因为当时它完全归 IBM 所有。

ALGOL 60 was the result of efforts to design a universal programming language for scientific applications. By late 1954, the Laning and Zierler algebraic system had been in operation for over a year, and the first report on Fortran had been published. Fortran became a reality in 1957, and several other high-level languages were being developed. Most notable among them were IT, which was designed by Alan Perlis at Carnegie Tech, and two languages for the UNIVAC computers, MATH-MATIC and UNICODE. The proliferation of languages made program sharing among users difficult. Furthermore, the new languages were all growing up around single architectures, some for UNIVAC computers and some for IBM 700-series machines. In response to this blossoming of machine-dependent languages, several major computer user groups in the United States, including SHARE (the IBM scientific user group) and USE (UNIVAC Scientific Exchange, the large-scale UNIVAC scientific user group), submitted a petition to the Association for Computing Machinery (ACM) on May 10, 1957, to form a committee to study and recommend action to create a machine-independent scientific programming language. Although Fortran might have been a candidate, it could not become a universal language, because at the time it was solely owned by IBM.

此前，1955 年，GAMM（应用数学和力学学会的德语缩写）成立了一个委员会，旨在设计一种通用的、独立于机器的算法语言。欧洲人之所以渴望开发这种新语言，部分原因是担心被 IBM 所主宰。然而，到 1957 年底，美国出现了几种高级语言，这让 GAMM 小组委员会确信，他们的努力必须扩大到包括美国人，于是他们向 ACM 发出了邀请函。1958 年 4 月，在 GAMM 的 Fritz Bauer 向 ACM 提交了正式提案后，两个小组正式同意开展联合语言设计项目。

Previously, in 1955, GAMM (a German acronym for Society for Applied Mathematics and Mechanics) had formed a committee to design one universal, machine-independent algorithmic language. The desire for this new language was in part due to the Europeans’ fear of being dominated by IBM. By late 1957, however, the appearance of several high-level languages in the United States convinced the GAMM subcommittee that their effort had to be widened to include the Americans, and a letter of invitation was sent to ACM. In April 1958, after Fritz Bauer of GAMM presented the formal proposal to ACM, the two groups officially agreed to a joint language design project.

GAMM 和 ACM 各自派出四名成员参加第一次设计会议。会议于 1958 年 5 月 27 日至 6 月 1 日在苏黎世举行，会议最初为新语言设定了以下目标：

GAMM and ACM each sent four members to the first design meeting. The meeting, which was held in Zurich from May 27 to June 1, 1958, began with the following goals for the new language:

• 该语言的语法应该尽可能接近标准数学符号，并且用该语言编写的程序应该易于阅读且无需进一步解释。

• The syntax of the language should be as close as possible to standard mathematical notation, and programs written in it should be readable with little further explanation.

• 应该可以使用该语言来描述印刷出版物中的算法。

• It should be possible to use the language for the description of algorithms in printed publications.

• 新语言程序必须能够机械地翻译成机器语言。

• Programs in the new language must be mechanically translatable into machine language.

第一个目标表明新语言将用于科学编程，这是当时计算机的主要应用领域。第二个目标对计算业务来说是一个全新的事物。最后一个目标对于任何编程语言来说都是显而易见的必需品。

The first goal indicated that the new language was to be used for scientific programming, which was the primary computer application area at that time. The second was something entirely new to the computing business. The last goal is an obvious necessity for any programming language.

苏黎世会议成功制定出了一种符合既定目标的语言，但设计过程需要无数的妥协，既有个人之间，也有大西洋两岸之间。在某些情况下，妥协并不只是针对重大问题，而是针对势力范围。小数点应该用逗号（欧洲方法）还是句号（美国方法）就是一个例子。

The Zurich meeting succeeded in producing a language that met the stated goals, but the design process required innumerable compromises, both among individuals and between the two sides of the Atlantic. In some cases, the compromises were not so much over great issues as they were over spheres of influence. The question of whether to use a comma (the European method) or a period (the American method) for a decimal point is one example.

苏黎世会议上设计的语言被命名为国际算法语言 (IAL)。在设计过程中，有人建议将该语言命名为 ALGOL，即算法语言，但该名称被否决，因为它不能反映委员会的国际范围。然而，在第二年，该语言的名称被更改为 ALGOL，随后被称为 ALGOL 58。

The language designed at the Zurich meeting was named the International Algorithmic Language (IAL). It was suggested during the design that the language be named ALGOL, for ALGOrithmic Language, but the name was rejected because it did not reflect the international scope of the committee. During the following year, however, the name was changed to ALGOL, and the language subsequently became known as ALGOL 58.

从很多方面来看，ALGOL 58 都是 Fortran 的后代，这很自然。它概括了 Fortran 的许多功能，并增加了几个新的结构和概念。其中一些概括与不将语言绑定到任何特定机器的目标有关，而另一些概括则试图使语言更加灵活和强大。这种努力产生了一种罕见的简单和优雅的结合。

In many ways, ALGOL 58 was a descendant of Fortran, which is quite natural. It generalized many of Fortran’s features and added several new constructs and concepts. Some of the generalizations had to do with the goal of not tying the language to any particular machine, and others were attempts to make the language more flexible and powerful. A rare combination of simplicity and elegance emerged from the effort.

ALGOL 58 形式化了数据类型的概念，尽管只有非浮点变量才需要显式声明。它增加了复合语句的概念，大多数后续语言都采用了这种概念。Fortran 的一些通用特性如下：标识符可以有任意长度，而 Fortran I 则限制为六个或更少的字符；允许任意数量的数组维数，而 Fortran I 则限制为不超过三个；数组的下限可以由程序员指定，而在 Fortran 中它隐式为 1；允许嵌套选择语句，而 Fortran I 则不允许。

ALGOL 58 formalized the concept of data type, although only variables that were not floating-point required explicit declaration. It added the idea of compound statements, which most subsequent languages incorporated. Some features of Fortran that were generalized were the following: Identifiers were allowed to have any length, as opposed to Fortran I’s restriction to six or fewer characters; any number of array dimensions was allowed, unlike Fortran I’s limitation to no more than three; the lower bound of arrays could be specified by the programmer, whereas in Fortran it was implicitly 1; nested selection statements were allowed, which was not the case in Fortran I.

ALGOL 58 以一种相当不寻常的方式获得了赋值运算符。Zuse 使用的形式

ALGOL 58 acquired the assignment operator in a rather unusual way. Zuse used the form

• 表达式=>变量

• expression => variable

Plankalkül 中的赋值语句。尽管 Plankalkül 尚未发布，但 ALGOL 58 委员会的一些欧洲成员熟悉该语言。委员会尝试了 Plankalkül 赋值形式，但由于字符集限制的争论，4大于号被改为冒号。然后，在很大程度上在美国人的坚持下，整个语句被转换为 Fortran 形式

for the assignment statement in Plankalkül. Although Plankalkül had not yet been published, some of the European members of the ALGOL 58 committee were familiar with the language. The committee dabbled with the Plankalkül assignment form but, because of arguments about character set limitations,4 the greater-than symbol was changed to a colon. Then, largely at the insistence of the Americans, the whole statement was turned around to the Fortran form

• 变量:=表达式

• variable := expression

欧洲人更喜欢相反的形式，但这与 Fortran 相反。

The Europeans preferred the opposite form, but that would be the reverse of Fortran.

1958 年 12 月，ALGOL 58 报告（Perlis 和 Samelson，1958）的发布受到了热烈欢迎。在美国，这种新语言更多地被视为编程语言设计思想的集合，而非通用标准语言。实际上，ALGOL 58 报告并不是一个成品，而是一个供国际讨论的初步文件。尽管如此，三项主要的设计和实现工作都以该报告为基础。在密歇根大学，MAD 语言诞生了（Arden 等人，1961）。美国海军电子组开发了 NELIAC 语言（Huskey 等人，1963）。系统开发公司设计并实现了 JOVIAL（Shaw，1963）。 JOVIAL 是 Jules 自己的国际代数语言版本的首字母缩写，它是唯一一种基于 ALGOL 58 并得到广泛使用的语言（Jules 是 Jules I. Schwartz，JOVIAL 的设计者之一）。JOVIAL 之所以得到广泛使用，是因为它曾是美国空军四分之一世纪的官方科学语言。

In December 1958, publication of the ALGOL 58 report (Perlis and Samelson, 1958) was greeted with enthusiasm. In the United States, the new language was viewed more as a collection of ideas for programming language design than as a universal standard language. Actually, the ALGOL 58 report was not meant to be a finished product but rather a preliminary document for international discussion. Nevertheless, three major design and implementation efforts used the report as their basis. At the University of Michigan, the MAD language was born (Arden et al., 1961). The U.S. Naval Electronics Group produced the NELIAC language (Huskey et al., 1963). At System Development Corporation, JOVIAL was designed and implemented (Shaw, 1963). JOVIAL, an acronym for Jules’ Own Version of the International Algebraic Language, represents the only language based on ALGOL 58 to achieve widespread use (Jules was Jules I. Schwartz, one of JOVIAL’s designers). JOVIAL became widely used because it was the official scientific language for the U.S. Air Force for a quarter century.

美国计算机界的其他人对这种新语言并不那么友好。起初，IBM 及其主要科学用户组 SHARE 似乎都接受了 ALGOL 58。IBM 在报告发布后不久就开始实施，SHARE 成立了一个小组委员会 SHARE IAL 来研究这种语言。小组委员会随后建议 ACM 将 ALGOL 58 标准化，并建议 IBM 为所有 700 系列计算机实施它。然而，这种热情是短暂的。到 1959 年春天，IBM 和 SHARE 凭借其 Fortran 经验，已经受够了开始使用一种新语言的痛苦和花费，无论是在开发和使用第一代编译器方面，还是在培训用户使用新语言并说服他们使用新语言方面。到 1959 年中期，IBM 和 SHARE 都对 Fortran 产生了浓厚的兴趣，因此他们决定保留它作为IBM 700 系列机器的科学语言，从而放弃了 ALGOL 58 。

The rest of the U.S. computing community was not so kind to the new language. At first, both IBM and its major scientific user group, SHARE, seemed to embrace ALGOL 58. IBM began an implementation shortly after the report was published, and SHARE formed a subcommittee, SHARE IAL, to study the language. The subcommittee subsequently recommended that ACM standardize ALGOL 58 and that IBM implement it for all of the 700-series computers. The enthusiasm was short-lived, however. By the spring of 1959, both IBM and SHARE, through their Fortran experience, had had enough of the pain and expense of getting a new language started, both in terms of developing and using the first-generation compilers and in terms of training users in the new language and persuading them to use it. By the middle of 1959, both IBM and SHARE had developed such a vested interest in Fortran that they decided to retain it as the scientific language for the IBM 700-series machines, thereby abandoning ALGOL 58.

1959 年，欧洲和美国都对 ALGOL 58 进行了激烈的辩论。欧洲版《ALGOL 公报》和《ACM 通讯》刊登了大量修改和补充建议。1959 年最重要的事件之一是苏黎世委员会向国际信息处理大会提交了他们的工作成果，因为巴克斯在会上介绍了一种描述编程语言语法的新符号，后来被称为 BNF（Backus-Naur 范式）。第3章 详细介绍了 BNF 。

During 1959, ALGOL 58 was furiously debated in both Europe and the United States. Large numbers of suggested modifications and additions were published in the European ALGOL Bulletin and in Communications of the ACM. One of the most important events of 1959 was the presentation of the work of the Zurich committee to the International Conference on Information Processing, for there Backus introduced his new notation for describing the syntax of programming languages, which later became known as BNF (Backus-Naur form). BNF is described in detail in Chapter 3.

1960 年 1 月，第二次 ALGOL 会议在巴黎举行。会议的目的是讨论正式提交审议的 80 条建议。丹麦的 Peter Naur 深度参与了 ALGOL 的开发，尽管他没有苏黎世小组成员。Naur 创建并出版了《ALGOL 公报》。他花了大量时间研究 Backus 介绍 BNF 的论文，并决定应该使用 BNF 来正式描述 1960 年会议的结果。在对 BNF 进行一些相对较小的修改后，他用 BNF 编写了新提议语言的描述，并在会议开始时将其分发给 1960 年小组的成员。

In January 1960, the second ALGOL meeting was held, this time in Paris. The purpose of the meeting was to debate the 80 suggestions that had been formally submitted for consideration. Peter Naur of Denmark had become heavily involved in the development of ALGOL, even though he had not been a member of the Zurich group. It was Naur who created and published the ALGOL Bulletin. He spent a good deal of time studying Backus’s paper that introduced BNF and decided that BNF should be used to describe formally the results of the 1960 meeting. After making a few relatively minor changes to BNF, he wrote a description of the new proposed language in BNF and handed it out to the members of the 1960 group at the beginning of the meeting.

尽管 1960 年的会议只持续了六天，但对 ALGOL 58 的修改却非常显著。其中最重要的新进展包括：

Although the 1960 meeting lasted only six days, the modifications made to ALGOL 58 were dramatic. Among the most important new developments were the following:

• 引入了块结构的概念。这允许程序员通过引入新的数据环境或范围来本地化程序的某些部分。

• The concept of block structure was introduced. This allowed the programmer to localize parts of programs by introducing new data environments, or scopes.

• 允许使用两种不同的方式向子程序传递参数：按值传递和按名称传递。

• Two different means of passing parameters to subprograms were allowed: pass by value and pass by name.

• 程序允许递归。ALGOL 58 的描述对这个问题没有明确说明。请注意，虽然递归对于命令式语言来说是新事物，但 Lisp 早在 1959 年就提供了递归函数。

• Procedures were allowed to be recursive. The ALGOL 58 description was unclear on this issue. Note that although recursion was new for the imperative languages, Lisp had already provided recursive functions in 1959.

• 允许使用堆栈动态数组。堆栈动态数组的下标范围由变量指定，因此数组的大小是在为数组分配存储空间时设置的，这发生在执行期间到达声明时。第6章 详细介绍了堆栈动态数组。

• Stack-dynamic arrays were allowed. A stack-dynamic array is one for which the subscript range or ranges are specified by variables, so that the size of the array is set at the time storage is allocated to the array, which happens when the declaration is reached during execution. Stack-dynamic arrays are described in detail in Chapter 6.

一些可能对该语言的成败产生重大影响的功能被提出但被否决。其中最重要的是带格式的输入和输出语句，这些功能被省略，因为它们被认为是与机器相关的。

Several features that might have had a dramatic impact on the success or failure of the language were proposed and rejected. Most important among these were input and output statements with formatting, which were omitted because they were thought to be machine-dependent.

ALGOL 60 报告于 1960 年 5 月发布（Naur，1960 年）。语言描述中仍存在一些模糊之处，第三次会议定于 1962 年 4 月在罗马举行，以解决这些问题。在这次会议上，小组只处理问题；不允许对该语言进行任何添加。这次会议的结果以“算法语言 ALGOL 60 修订报告”为标题发表（Backus 等人，1963 年）。

The ALGOL 60 report was published in May 1960 (Naur, 1960). A number of ambiguities still remained in the language description, and a third meeting was scheduled for April 1962 in Rome to address the problems. At this meeting the group dealt only with problems; no additions to the language were allowed. The results of this meeting were published under the title “Revised Report on the Algorithmic Language ALGOL 60” (Backus et al., 1963).

从某些方面来看，ALGOL 60 是一个巨大的成功；从其他方面来看，它却是一个惨败。它几乎立刻就成为计算文献中唯一可接受的算法交流形式，并且保持了 20 多年的地位。自 1960 年以来设计的每一种命令式编程语言都在某种程度上归功于 ALGOL 60。事实上，大多数都是直接的或间接后代；例如 PL/I、SIMULA 67、ALGOL 68、C、Pascal、Ada、C++、Java 和 C#。

In some ways, ALGOL 60 was a great success; in other ways, it was a dismal failure. It succeeded in becoming, almost immediately, the only acceptable formal means of communicating algorithms in computing literature, and it remained that for more than 20 years. Every imperative programming language designed since 1960 owes something to ALGOL 60. In fact, most are direct or indirect descendants; examples include PL/I, SIMULA 67, ALGOL 68, C, Pascal, Ada, C++, Java, and C#.

ALGOL 58/ALGOL 60 的设计工作包括一系列的“第一”。这是国际团队首次尝试设计一种编程语言。这是第一种设计为独立于机器的语言。它也是第一种语法被正式描述的语言。BNF 形式主义的成功使用开创了计算机科学的几个重要领域：形式语言、解析理论和基于 BNF 的编译器设计。最后，ALGOL 60 的结构影响了机器架构。最引人注目的例子是，该语言的扩展被用作一系列大型计算机（Burroughs B5000、B6000 和 B7000 机器）的系统语言，这些机器采用硬件堆栈设计，以高效地实现语言的块结构和递归子程序。

The ALGOL 58/ALGOL 60 design effort included a long list of firsts. It was the first time that an international group attempted to design a programming language. It was the first language that was designed to be machine independent. It was also the first language whose syntax was formally described. This successful use of the BNF formalism initiated several important fields of computer science: formal languages, parsing theory, and BNF-based compiler design. Finally, the structure of ALGOL 60 affected machine architecture. In the most striking example of this, an extension of the language was used as the systems language of a series of large-scale computers, the Burroughs B5000, B6000, and B7000 machines, which were designed with a hardware stack to implement efficiently the block structure and recursive subprograms of the language.

另一方面，ALGOL 60 在美国从未得到广泛使用。即使在欧洲，它也从未成为主流语言。它未被接受的原因有很多。首先，ALGOL 60 的某些特性过于灵活；它们使得理解困难且实现效率低下。最好的例子是将参数传递给子程序的按名称传递方法，这将在第 9章中 解释。实现 ALGOL 60 的困难可以从 Rutishauser 在 1967 年的声明中看出，几乎没有实现包含完整的 ALGOL 60 语言（Rutishauser，1967 年，第 8 页）。

On the other side of the coin, ALGOL 60 never achieved widespread use in the United States. Even in Europe, where it was more popular than in the United States, it never became the dominant language. There are a number of reasons for its lack of acceptance. For one thing, some of the features of ALGOL 60 turned out to be too flexible; they made understanding difficult and implementation inefficient. The best example of this is the pass-by-name method of passing parameters to subprograms, which is explained in Chapter 9. The difficulties of implementing ALGOL 60 are evidenced by Rutishauser’s statement in 1967 that few, if any, implementations included the full ALGOL 60 language (Rutishauser, 1967, p. 8).

该语言缺乏输入和输出语句是其未被接受的另一个主要原因。依赖于实现的输入/输出使得程序很难移植到其他计算机。

The lack of input and output statements in the language was another major reason for its lack of acceptance. Implementation-dependent input/output made programs difficult to port to other computers.

讽刺的是，ALGOL 60 对计算机科学最重要的贡献之一 BNF 也是其未被接受的一个因素。尽管 BNF 现在被认为是一种简单而优雅的语法描述方式，但在 1960 年，它似乎很奇怪和复杂。

Ironically, one of the most important contributions to computer science associated with ALGOL 60, BNF, was also a factor in its lack of acceptance. Although BNF is now considered a simple and elegant means of syntax description, in 1960 it seemed strange and complicated.

最后，尽管还存在许多其他问题，但 Fortran 在用户中的根深蒂固以及 IBM 缺乏支持可能是 ALGOL 60 未能得到广泛应用的最重要因素。

Finally, although there were many other problems, the entrenchment of Fortran among users and the lack of support by IBM were probably the most important factors in ALGOL 60’s failure to gain widespread use.

ALGOL 60 的努力从未真正完成，因为歧义和模糊性始终是语言描述的一部分（Knuth，1967）。

The ALGOL 60 effort was never really complete, in the sense that ambiguities and obscurities were always a part of the language description (Knuth, 1967).

以下是 ALGOL 60 程序的示例：

The following is an example of an ALGOL 60 program:

comment ALGOL 60 Example Program
 Input:  An integer, listlen, where listlen is less than
         100, followed by listlen-integer values
 Output: The number of input values that are greater than
         the average of all the input values ;
begin
  integer array intlist [1:99];
  integer listlen, counter, sum, average, result;
  sum := 0;
  result := 0;
  readint (listlen);
  if (listlen > 0) ^ (listlen < 100) then
    begin
comment Read input into an array and compute the average;
    for counter := 1 step 1 until listlen do
      begin
      readint (intlist[counter]);
      sum := sum + intlist[counter]
      end;
comment Compute the average;
    average := sum / listlen;
comment Count the input values that are > average;
    for counter := 1 step 1 until listlen do
      if intlist[counter] > average
        then result := result + 1;
comment Print result;
    printstring("The number of values > average is:");
    printint (result)
    end
  else
    printstring ("Error-input list length is not legal";
end 

comment ALGOL 60 Example Program
 Input:  An integer, listlen, where listlen is less than
         100, followed by listlen-integer values
 Output: The number of input values that are greater than
         the average of all the input values ;
begin
  integer array intlist [1:99];
  integer listlen, counter, sum, average, result;
  sum := 0;
  result := 0;
  readint (listlen);
  if (listlen > 0) ^ (listlen < 100) then
    begin
comment Read input into an array and compute the average;
    for counter := 1 step 1 until listlen do
      begin
      readint (intlist[counter]);
      sum := sum + intlist[counter]
      end;
comment Compute the average;
    average := sum / listlen;
comment Count the input values that are > average;
    for counter := 1 step 1 until listlen do
      if intlist[counter] > average
        then result := result + 1;
comment Print result;
    printstring("The number of values > average is:");
    printint (result)
    end
  else
    printstring ("Error-input list length is not legal";
end 

COBOL 的起源与 ALGOL 60 有些相似，因为该语言是由一个相对较短时间的委员会设计的。当时，即 1959 年，商业计算的状态与几年前 Fortran 设计时的科学计算状态相似。一种用于商业应用的编译语言 FLOW-MATIC 已于 1957 年实现，但它属于一家制造商 UNIVAC，并且是为该公司的计算机设计的。另一种语言 AIMACO 正在被美国空军使用，但它只是 FLOW-MATIC 的一个微小变体。IBM 已经设计了一种用于商业应用的编程语言 COMTRAN（商业翻译器），但尚未实现。当时正在计划其他几个语言设计项目。

The beginning of COBOL is somewhat similar to that of ALGOL 60, in the sense that the language was designed by a committee of people meeting for relatively short periods of time. At the time, in 1959, the state of business computing was similar to the state of scientific computing several years earlier, when Fortran was being designed. One compiled language for business applications, FLOW-MATIC, had been implemented in 1957, but it belonged to one manufacturer, UNIVAC, and was designed for that company’s computers. Another language, AIMACO, was being used by the U.S. Air Force, but it was only a minor variation of FLOW-MATIC. IBM had designed a programming language for business applications, COMTRAN (COMmercial TRANslator), but it had not yet been implemented. Several other language design projects were being planned.

FLOW-MATIC 的起源值得至少简要讨论一下，因为它是 COBOL 的主要前身。1953 年 12 月，雷明顿-兰德 UNIVAC 的 Grace Hopper 写了一份确实具有预言性的提案。它建议“数学程序应该用数学符号编写，数据处理程序应该用英文语句编写”（Wexelblat，1981，第 16 页）。不幸的是，在 1953 年，不可能让非程序员相信计算机可以理解英文单词。直到 1955 年，类似的提案才有希望得到 UNIVAC 管理层的资助，即使在那时，也需要使用原型系统来做最后的说服工作。这个销售过程的一部分涉及编译和运行一个小程序，首先使用英文关键字，然后使用法文关键字，最后使用德文关键字。UNIVAC 管理层认为这次演示非常了不起，并促使他们接受了 Hopper 的提议。

The origins of FLOW-MATIC are worth at least a brief discussion, because it was the primary progenitor of COBOL. In December 1953, Grace Hopper at Remington-Rand UNIVAC wrote a proposal that was indeed prophetic. It suggested that “mathematical programs should be written in mathematical notation, data processing programs should be written in English statements” (Wexelblat, 1981, p. 16). Unfortunately, in 1953, it was impossible to convince nonprogrammers that a computer could be made to understand English words. It was not until 1955 that a similar proposal had some hope of being funded by UNIVAC management, and even then it took a prototype system to do the final convincing. Part of this selling process involved compiling and running a small program, first using English keywords, then using French keywords, and then using German keywords. This demonstration was considered remarkable by UNIVAC management and was instrumental in their acceptance of Hopper’s proposal.

1959 年 5 月 28 日至 29 日（苏黎世 ALGOL 会议刚好一周年），在五角大楼举行了第一次关于商业应用通用语言的正式会议，会议由国防部主办。与会人员一致认为，这种当时被称为 CBL（通用商业语言）的语言应具备以下一般特征：大多数人同意应尽可能使用英语，尽管也有少数人主张使用更多的数学符号。该语言必须易于使用，即使功能不够强大，也能扩大计算机编程人员的范围。除了使语言易于使用之外，人们还认为使用英语可以让管理人员更容易阅读程序。最后，设计不应受到其实施问题的过度限制。

The first formal meeting on the subject of a common language for business applications, which was sponsored by the Department of Defense, was held at the Pentagon on May 28 and 29, 1959 (exactly one year after the Zurich ALGOL meeting). The consensus of the group was that the language, then named CBL (Common Business Language), should have the following general characteristics: Most agreed that it should use English as much as possible, although a few argued for a more mathematical notation. The language must be easy to use, even at the expense of being less powerful, in order to broaden the base of those who could program computers. In addition to making the language easy to use, it was believed that the use of English would allow managers to read programs. Finally, the design should not be overly restricted by the problems of its implementation.

会议上最受关注的问题之一是应迅速采取措施创建这种通用语言，因为创建其他商业语言的工作已经开展得非常多了。除了现有语言外，RCA 和 Sylvania 还在开发自己的商业应用语言。很明显，开发通用语言所花的时间越长，该语言被广泛使用的难度就越大。在此基础上，大家决定应快速研究现有语言。为此，成立了短期委员会。

One of the overriding concerns at the meeting was that steps to create this universal language should be taken quickly, as a lot of work was already being done to create other business languages. In addition to the existing languages, RCA and Sylvania were working on their own business applications languages. It was clear that the longer it took to produce a universal language, the more difficult it would be for the language to become widely used. On this basis, it was decided that there should be a quick study of existing languages. For this task, the Short Range Committee was formed.

早期曾决定将语言的语句分为两类——数据描述和可执行操作——并将这两类语句放在程序的不同部分。短程委员会的争论之一是关于是否包含下标。许多委员会成员认为，下标对于数据处理人员来说太复杂了，因为他们不熟悉数学符号。类似的争论围绕着是否应该包含算术表达式。短程委员会的最终报告于 1959 年 12 月完成，描述了后来被命名为 COBOL 60 的语言。

There were early decisions to separate the statements of the language into two categories—data description and executable operations—and to have statements in these two categories be in different parts of programs. One of the debates of the Short Range Committee was over the inclusion of subscripts. Many committee members argued that subscripts were too complex for the people in data processing, who were thought to be uncomfortable with mathematical notation. Similar arguments revolved around whether arithmetic expressions should be included. The final report of the Short Range Committee, which was completed in December 1959, described the language that was later named COBOL 60.

美国政府印刷局于 1960 年 4 月发布了 COBOL 60 语言规范（国防部，1960 年），该规范被称为“初始版”。修订版于 1961 年和 1962 年发布（国防部，1961 年、1962 年）。该语言于 1968 年由美国国家标准协会 (ANSI) 小组标准化。接下来的三次修订版分别于 1974 年、1985 年和 2002 年由 ANSI 标准化。该语言至今仍在不断发展。

The language specification for COBOL 60, published by the Government Printing Office in April 1960 (Department of Defense, 1960), was described as “initial.” Revised versions were published in 1961 and 1962 (Department of Defense, 1961, 1962). The language was standardized by the American National Standards Institute (ANSI) group in 1968. The next three revisions were standardized by ANSI in 1974, 1985, and 2002. The language continues to evolve today.

COBOL 语言催生了许多新概念，其中一些最终出现在其他语言中。例如，DEFINECOBOL 60 的动词是第一个用于宏的高级语言构造。更重要的是，首次出现在 Plankalkül 中的分层数据结构（记录）首先在 COBOL 中实现。此后设计的大多数命令式语言都包含它们。COBOL 也是第一个允许名称真正具有内涵的语言，因为它允许使用长名称（最多 30 个字符）和单词连接符（连字符）。

The COBOL language originated a number of novel concepts, some of which eventually appeared in other languages. For example, the DEFINE verb of COBOL 60 was the first high-level language construct for macros. More important, hierarchical data structures (records), which first appeared in Plankalkül, were first implemented in COBOL. They have been included in most of the imperative languages designed since then. COBOL was also the first language that allowed names to be truly connotative, because it allowed both long names (up to 30 characters) and word-connector characters (hyphens).

总体而言，数据部分是 COBOL 设计的强项，而过程部分则相对较弱。数据部分中详细定义了每个变量，包括小数位数和隐含小数点的位置。文件记录也以这种详细程度进行描述，要输出到打印机的行也是如此，这使得 COBOL 成为打印会计报告的理想选择。原始过程部分最重要的弱点可能在于缺乏功能。1974 年标准之前的 COBOL 版本也不允许使用带参数的子程序。

Overall, the data division is the strong part of COBOL’s design, whereas the procedure division is relatively weak. Every variable is defined in detail in the data division, including the number of decimal digits and the location of the implied decimal point. File records are also described with this level of detail, as are lines to be output to a printer, which makes COBOL ideal for printing accounting reports. Perhaps the most important weakness of the original procedure division was in its lack of functions. Versions of COBOL prior to the 1974 standard also did not allow subprograms with parameters.

我们对 COBOL 的最终评价是：它是第一种由国防部 (DoD) 强制使用的编程语言。该强制要求在其最初开发之后，COBOL 就不再被使用，因为 COBOL 并非专门为国防部设计的。尽管 COBOL 有其优点，但如果没有这一规定，它很可能无法生存。早期编译器的性能不佳，导致该语言使用成本过高。当然，最终编译器变得更高效，计算机变得更快、更便宜，内存也更大。这些因素共同使 COBOL 在国防部内外都获得了成功。它的出现导致了会计的电子机械化，无论以何种标准衡量，这都是一项重要的发展。

Our final comment on COBOL: It was the first programming language whose use was mandated by the Department of Defense (DoD). This mandate came after its initial development, because COBOL was not designed specifically for the DoD. In spite of its merits, COBOL probably would not have survived without that mandate. The poor performance of the early compilers simply made the language too expensive to use. Eventually, of course, compilers became more efficient and computers became much faster and cheaper and had much larger memories. Together, these factors allowed COBOL to succeed, inside and outside DoD. Its appearance led to the electronic mechanization of accounting, an important development by any measure.

以下是 COBOL 程序的示例。此程序读取名为 的文件，BAL-FWD-File其中包含有关特定物品集合的库存信息。除其他信息外，每个物品记录包括当前库存数量 ( BAL-ON-HAND) 和物品的重新订购点 ( BAL-REORDER-POINT)。重新订购点是库存物品的阈值，达到该阈值时必须订购更多物品。该程序生成必须重新订购的物品列表，作为名为 的文件REORDER-LISTING。

The following is an example of a COBOL program. This program reads a file named BAL-FWD-File that contains inventory information about a certain collection of items. Among other things, each item record includes the number currently on hand (BAL-ON-HAND) and the item’s reorder point (BAL-REORDER-POINT). The reorder point is the threshold number of items on hand at which more must be ordered. The program produces a list of items that must be reordered as a file named REORDER-LISTING.

IDENTIFICATION DIVISION.
PROGRAM-ID. PRODUCE-REORDER-LISTING.

ENVIRONMENT DIVISION.
CONFIGURATION SECTION.
SOURCE-COMPUTER. DEC-VAX.
OBJECT-COMPUTER. DEC-VAX.
INPUT-OUTPUT SECTION.
FILE-CONTROL.
    SELECT BAL-FWD-FILE ASSIGN TO READER.
    SELECT REORDER-LISTING ASSIGN TO LOCAL-PRINTER.

DATA DIVISION.
FILE SECTION.
FD  BAL-FWD-FILE
    LABEL RECORDS ARE STANDARD
    RECORD CONTAINS 80 CHARACTERS.

01  BAL-FWD-CARD.
    02 BAL-ITEM-NO          PICTURE IS 9(5).
    02 BAL-ITEM-DESC        PICTURE IS X(20).
    02 FILLER               PICTURE IS X(5).
    02 BAL-UNIT-PRICE       PICTURE IS 999V99.
    02 BAL-REORDER-POINT    PICTURE IS 9(5).
    02 BAL-ON-HAND          PICTURE IS 9(5).
    02 BAL-ON-ORDER         PICTURE IS 9(5).
    02 FILLER               PICTURE IS X(30).
FD  REORDER-LISTING
    LABEL RECORDS ARE STANDARD
    RECORD CONTAINS 132 CHARACTERS.

01  REORDER-LINE.
    02 RL-ITEM-NO           PICTURE IS Z(5).
    02 FILLER               PICTURE IS X(5).
    02 RL-ITEM-DESC         PICTURE IS X(20).
    02 FILLER               PICTURE IS X(5).
    02 RL-UNIT-PRICE        PICTURE IS ZZZ.99.
    02 FILLER               PICTURE IS X(5).
    02 RL-AVAILABLE-STOCK   PICTURE IS Z(5).
    02 FILLER               PICTURE IS X(5).
    02 RL-REORDER-POINT     PICTURE IS Z(5).
    02 FILLER               PICTURE IS X(71).

WORKING-STORAGE SECTION.
01  SWITCHES.
    02 CARD-EOF-SWITCH      PICTURE IS X.
01  WORK-FIELDS.
    02 AVAILABLE-STOCK      PICTURE IS 9(5).

PROCEDURE DIVISION.
000-PRODUCE-REORDER-LISTING.
    OPEN INPUT BAL-FWD-FILE.
    OPEN OUTPUT REORDER-LISTING.
    MOVE "N" TO CARD-EOF-SWITCH.
    PERFORM 100-PRODUCE-REORDER-LINE
        UNTIL CARD-EOF-SWITCH IS EQUAL TO "Y".
    CLOSE BAL-FWD-File.
    CLOSE REORDER-LISTING.
    STOP RUN.

100-PRODUCE-REORDER-LINE.
    PERFORM 110-READ-INVENTORY-RECORD.
    IF CARD-EOF-SWITCH IS NOT EQUAL TO "Y"]
        PERFORM 120-CALCULATE-AVAILABLE-STOCK
        IF AVAILABLE-STOCK IS LESS THAN BAL-REORDER-POINT
            PERFORM 130-PRINT-REORDER-LINE.

110-READ-INVENTORY-RECORD.
    READ BAL-FWD-FILE RECORD
         AT END
             MOVE "Y" TO CARD-EOF-SWITCH.

120-CALCULATE-AVAILABLE-STOCK.
ADD BAL-ON-HAND BAL-ON-ORDER
    GIVING AVAILABLE-STOCK.

130-PRINT-REORDER-LINE.
    MOVE SPACE               TO REORDER-LINE.
    MOVE BAL-ITEM-NO         TO RL-ITEM-NO.
    MOVE BAL-ITEM-DESC       TO RL-ITEM-DESC.
    MOVE BAL-UNIT-PRICE      TO RL-UNIT-PRICE.
    MOVE AVAILABLE-STOCK     TO RL-AVAILABLE-STOCK.
    MOVE BAL-REORDER-POINT   TO RL-REORDER-POINT.
    WRITE REORDER-LINE.

IDENTIFICATION DIVISION.
PROGRAM-ID. PRODUCE-REORDER-LISTING.

ENVIRONMENT DIVISION.
CONFIGURATION SECTION.
SOURCE-COMPUTER. DEC-VAX.
OBJECT-COMPUTER. DEC-VAX.
INPUT-OUTPUT SECTION.
FILE-CONTROL.
    SELECT BAL-FWD-FILE ASSIGN TO READER.
    SELECT REORDER-LISTING ASSIGN TO LOCAL-PRINTER.

DATA DIVISION.
FILE SECTION.
FD  BAL-FWD-FILE
    LABEL RECORDS ARE STANDARD
    RECORD CONTAINS 80 CHARACTERS.

01  BAL-FWD-CARD.
    02 BAL-ITEM-NO          PICTURE IS 9(5).
    02 BAL-ITEM-DESC        PICTURE IS X(20).
    02 FILLER               PICTURE IS X(5).
    02 BAL-UNIT-PRICE       PICTURE IS 999V99.
    02 BAL-REORDER-POINT    PICTURE IS 9(5).
    02 BAL-ON-HAND          PICTURE IS 9(5).
    02 BAL-ON-ORDER         PICTURE IS 9(5).
    02 FILLER               PICTURE IS X(30).
FD  REORDER-LISTING
    LABEL RECORDS ARE STANDARD
    RECORD CONTAINS 132 CHARACTERS.

01  REORDER-LINE.
    02 RL-ITEM-NO           PICTURE IS Z(5).
    02 FILLER               PICTURE IS X(5).
    02 RL-ITEM-DESC         PICTURE IS X(20).
    02 FILLER               PICTURE IS X(5).
    02 RL-UNIT-PRICE        PICTURE IS ZZZ.99.
    02 FILLER               PICTURE IS X(5).
    02 RL-AVAILABLE-STOCK   PICTURE IS Z(5).
    02 FILLER               PICTURE IS X(5).
    02 RL-REORDER-POINT     PICTURE IS Z(5).
    02 FILLER               PICTURE IS X(71).

WORKING-STORAGE SECTION.
01  SWITCHES.
    02 CARD-EOF-SWITCH      PICTURE IS X.
01  WORK-FIELDS.
    02 AVAILABLE-STOCK      PICTURE IS 9(5).

PROCEDURE DIVISION.
000-PRODUCE-REORDER-LISTING.
    OPEN INPUT BAL-FWD-FILE.
    OPEN OUTPUT REORDER-LISTING.
    MOVE "N" TO CARD-EOF-SWITCH.
    PERFORM 100-PRODUCE-REORDER-LINE
        UNTIL CARD-EOF-SWITCH IS EQUAL TO "Y".
    CLOSE BAL-FWD-File.
    CLOSE REORDER-LISTING.
    STOP RUN.

100-PRODUCE-REORDER-LINE.
    PERFORM 110-READ-INVENTORY-RECORD.
    IF CARD-EOF-SWITCH IS NOT EQUAL TO "Y"]
        PERFORM 120-CALCULATE-AVAILABLE-STOCK
        IF AVAILABLE-STOCK IS LESS THAN BAL-REORDER-POINT
            PERFORM 130-PRINT-REORDER-LINE.

110-READ-INVENTORY-RECORD.
    READ BAL-FWD-FILE RECORD
         AT END
             MOVE "Y" TO CARD-EOF-SWITCH.

120-CALCULATE-AVAILABLE-STOCK.
ADD BAL-ON-HAND BAL-ON-ORDER
    GIVING AVAILABLE-STOCK.

130-PRINT-REORDER-LINE.
    MOVE SPACE               TO REORDER-LINE.
    MOVE BAL-ITEM-NO         TO RL-ITEM-NO.
    MOVE BAL-ITEM-DESC       TO RL-ITEM-DESC.
    MOVE BAL-UNIT-PRICE      TO RL-UNIT-PRICE.
    MOVE AVAILABLE-STOCK     TO RL-AVAILABLE-STOCK.
    MOVE BAL-REORDER-POINT   TO RL-REORDER-POINT.
    WRITE REORDER-LINE.

Basic（初学者通用符号指令代码）最初由两位数学家 John Kemeny 和 Thomas Kurtz 在新罕布什尔州的达特茅斯学院（现达特茅斯大学）设计，他们在 20 世纪 60 年代初开发了 Fortran 和 ALGOL 60 的各种方言的编译器。他们的理科生在学习或使用这些语言时通常没有遇到什么困难。然而，达特茅斯主要是一所文理学院，理工科学生仅占学生总数的 25% 左右。1963 年春天，他们决定专门为文科生设计一种新语言。这种新语言将使用终端作为计算机访问的方法。该系统的目标如下：

Basic (Beginner’s All-purpose Symbolic Instruction Code) was originally designed at Dartmouth College (now Dartmouth University) in New Hampshire by two mathematicians, John Kemeny and Thomas Kurtz, who, in the early 1960s, developed compilers for a variety of dialects of Fortran and ALGOL 60. Their science students generally had little trouble learning or using those languages in their studies. However, Dartmouth was primarily a liberal arts institution, where science and engineering students made up only about 25 percent of the student body. It was decided in the spring of 1963 to design a new language especially for liberal arts students. This new language would use terminals as the method of computer access. The goals of the system were as follows:

1. 它必须便于非科学专业的学生学习和使用。

2. It must be easy for nonscience students to learn and use.

3. 它必须“令人愉快且友好”。

4. It must be “pleasant and friendly.”

5. 它必须快速完成家庭作业。

6. It must provide fast turnaround for homework.

7. 它必须允许自由和私人访问。

8. It must allow free and private access.

9. 它必须认为用户时间比计算机时间更重要。

10. It must consider user time more important than computer time.

最后一个目标确实是一个革命性的概念。它至少部分基于这样的信念：随着时间的推移，计算机的价格将大幅下降，而事实确实如此。

The last goal was indeed a revolutionary concept. It was based at least partly on the belief that computers would become significantly cheaper as time went on, which they certainly did.

第二、第三和第四个目标的结合导致了 Basic 的分时特性。在 20 世纪 60 年代初期，只有通过大量用户同时通过终端进行单独访问，才能实现这些目标。

The combination of the second, third, and fourth goals led to the time-shared aspect of Basic. Only with individual access through terminals by numerous simultaneous users could these goals be met in the early 1960s.

1963 年夏天，Kemeny 开始开发 Basic 第一版的编译器，使用远程访问 GE 225 计算机。Basic 操作系统的设计和编码始于 1963 年秋天。1964年 5 月 1 日凌晨4 点，第一个使用分时 Basic 的程序被输入并运行。6 月份，系统上的终端数量增加到 11 个，到秋天则激增到 20 个。

In the summer of 1963, Kemeny began work on the compiler for the first version of Basic, using remote access to a GE 225 computer. Design and coding of the operating system for Basic began in the fall of 1963. At 4:00 a.m. on May 1, 1964, the first program using the timeshared Basic was typed in and run. In June, the number of terminals on the system grew to 11, and by the fall it had ballooned to 20.

最初的 Basic 版本非常小，而且奇怪的是，它不是交互式的：执行程序无法从用户那里获取输入数据。程序以一种面向批处理的方式输入、编译和运行。最初的 Basic 只有 14 种不同的语句类型和一种数据类型 — 浮点数。因为人们认为很少有目标用户会理解整数和浮点类型之间的区别，所以这种类型被称为“数字”。总的来说，这是一种功能非常有限的语言，但相当容易学习。

The original version of Basic was very small and, oddly, was not interactive: There was no way for an executing program to get input data from the user. Programs were typed in, compiled, and run, in a sort of batch-oriented way. The original Basic had only 14 different statement types and a single data type—floating-point. Because it was believed that few of the targeted users would appreciate the difference between integer and floating-point types, the type was referred to as “numbers.” Overall, it was a very limited language, though quite easy to learn.

最初的 Basic 最重要的方面是，它是第一种通过连接到远程计算机的终端使用的广泛使用的语言。7当时终端才刚刚开始出现。 在此之前，大多数程序都是通过打孔卡或纸带输入计算机的。

The most important aspect of the original Basic was that it was the first widely used language that was used through terminals connected to a remote computer.7 Terminals had just begun to be available at that time. Before then, most programs were entered into computers through either punched cards or paper tape.

Basic 的大部分设计都源自 Fortran，并受到 ALGOL 60 语法的轻微影响。后来，它以各种方式发展，但几乎没有做出任何努力来标准化它。美国国家标准协会发布了最低限度的 Basic 标准 ( ANSI, 1978b )，但这仅代表了语言功能的最低限度。事实上，最初的 Basic 与最低限度的 Basic 非常相似。

Much of the design of Basic came from Fortran, with some minor influence from the syntax of ALGOL 60. Later, it grew in a variety of ways, with little or no effort made to standardize it. The American National Standards Institute issued a Minimal Basic standard (ANSI, 1978b), but this represented only the bare minimum of language features. In fact, the original Basic was very similar to Minimal Basic.

尽管这可能看起来令人惊讶，但数字设备公司使用一个相当复杂的 Basic 版本（名为 Basic-PLUS）来编写重要的20 世纪 70 年代，他们为 PDP-11 小型计算机开发了最大的操作系统 RSTS 的部分。

Although it may seem surprising, Digital Equipment Corporation used a rather elaborate version of Basic named Basic-PLUS to write significant portions of their largest operating system for the PDP-11 minicomputers, RSTS, in the 1970s.

Basic 因用它编写的程序结构不良等问题而受到批评。根据第1章 中讨论的评估标准，特别是可读性和可靠性，该语言确实表现很差。显然，该语言的早期版本不适合也不应该用于任何大型的严肃程序。后来的版本更适合这类任务。

Basic has been criticized for the poor structure of programs written in it, among other things. By the evaluation criteria discussed in Chapter 1, specifically readability and reliability, the language does indeed fare very poorly. Clearly, the early versions of the language were not meant for and should not have been used for serious programs of any significant size. Later versions are much better suited to such tasks.

20 世纪 90 年代，Basic 的复兴是由 Visual Basic (VB) 的出现推动的。VB 之所以得到广泛使用，很大程度上是因为它提供了一种构建图形用户界面 (GUI) 的简单方法，因此得名 Visual Basic。当 .NET 出现时，VB 的新版本 VB.NET 也随之出现。尽管它与早期版本的 VB 有很大不同，但它很快就取代了旧语言。VB 和 .NET 版本之间最重要的区别可能在于，后者完全支持面向对象编程。

The resurgence of Basic in the 1990s was driven by the appearance of Visual Basic (VB). VB became widely used in large part because it provided a simple way of building graphical user interfaces (GUIs), hence the name Visual Basic. When .NET appeared, a new version of VB came with it, VB.NET. Although it was a significant departure from earlier versions of VB, it quickly displaced the older language. Perhaps the most important difference between VB and the .NET version is that the later version fully supports object-oriented programming.

以下是 Basic 程序的示例：

The following is an example of a Basic program:

REM  Basic Example Program
REM  Input:  An integer, listlen, where listlen is less
REM          than 100, followed by listlen-integer values
REM  Output: The number of input values that are greater
REM          than the average of all input values
  DIM intlist(99)
  result = 0
  sum = 0
  INPUT listlen
  IF listlen > 0 AND listlen < 100 THEN
REM  Read input into an array and compute the sum
   FOR counter = 1 TO listlen
     INPUT intlist(counter)
     sum = sum + intlist(counter)
   NEXT counter
REM  Compute the average
   average = sum / listlen
REM  Count the number of input values that are > average
   FOR counter = 1 TO listlen
     IF intlist(counter) > average
        THEN result = result + 1
   NEXT counter
REM  Print the result
    PRINT "The number of values that are > average is:";
           result
  ELSE
   PRINT "Error-input list length is not legal"
  END IF
END

REM  Basic Example Program
REM  Input:  An integer, listlen, where listlen is less
REM          than 100, followed by listlen-integer values
REM  Output: The number of input values that are greater
REM          than the average of all input values
  DIM intlist(99)
  result = 0
  sum = 0
  INPUT listlen
  IF listlen > 0 AND listlen < 100 THEN
REM  Read input into an array and compute the sum
   FOR counter = 1 TO listlen
     INPUT intlist(counter)
     sum = sum + intlist(counter)
   NEXT counter
REM  Compute the average
   average = sum / listlen
REM  Count the number of input values that are > average
   FOR counter = 1 TO listlen
     IF intlist(counter) > average
        THEN result = result + 1
   NEXT counter
REM  Print the result
    PRINT "The number of values that are > average is:";
           result
  ELSE
   PRINT "Error-input list length is not legal"
  END IF
END

与 Fortran 一样，PL/I 也是作为 IBM 产品开发的。到 20 世纪 60 年代初，工业计算机用户已经分成了两个截然不同的阵营：科学和商业。从 IBM 的角度来看，科学程序员可以使用大型 7090 或小型 1620 IBM 计算机。该组广泛使用浮点数据和数组。Fortran 是主要语言，尽管也使用了一些汇编语言。他们有自己的用户组 SHARE，并且与从事商业应用程序的任何人几乎没有联系。

Like Fortran, PL/I was developed as an IBM product. By the early 1960s, the users of computers in industry had settled into two separate and quite different camps: scientific and business. From the IBM point of view, scientific programmers could use either the large-scale 7090 or the small-scale 1620 IBM computers. This group used floating-point data and arrays extensively. Fortran was the primary language, although some assembly language also was used. They had their own user group, SHARE, and had little contact with anyone who worked on business applications.

对于商业应用，人们使用大型 7080 或小型 1401 IBM 计算机。他们需要十进制和字符串数据类型，以及复杂而高效的输入和输出设施。他们使用 COBOL，尽管在 1963 年初 PL/I 故事开始时，从汇编语言到 COBOL 的转换还远未完成。这类用户也有自己的用户组 GUIDE，并且很少与科学用户联系。

For business applications, people used the large 7080 or the small 1401 IBM computers. They needed the decimal and character string data types, as well as elaborate and efficient input and output facilities. They used COBOL, although in early 1963 when the PL/I story begins, the conversion from assembly language to COBOL was far from complete. This category of users also had its own user group, GUIDE, and seldom had contact with scientific users.

1963 年初，IBM 的规划人员察觉到这种情况开始发生变化。两个相距甚远的计算机用户群体正以一种被认为必定会产生问题的方式相互接近。科学家开始收集大量数据文件进行处理。这些数据需要更复杂、更高效的输入和输出设施。业务应用程序人员开始使用回归分析来构建管理信息系统，这需要浮点数据和数组。计算设备似乎很快就需要两台独立的计算机和技术人员，支持两种截然不同的编程语言。8

In early 1963, IBM planners perceived the beginnings of a change in this situation. The two widely separated computer user groups were moving toward each other in ways that were thought certain to create problems. Scientists began to gather large files of data to be processed. This data required more sophisticated and more efficient input and output facilities. Business applications people began to use regression analysis to build management information systems, which required floating-point data and arrays. It began to appear that computing installations would soon require two separate computers and technical staffs, supporting two very different programming languages.8

这些看法自然而然地导致了设计一台通用计算机的概念，该计算机既能进行浮点运算，又能进行十进制运算，因此既能用于科学应用，又能用于商业应用。IBM System/360 系列计算机的概念由此诞生。随之而来的是，一种既能用于商业应用，又能用于科学应用的编程语言的想法。此外，还加入了支持系统编程和列表处理的功能。因此，新语言将取代 Fortran、COBOL、Lisp 和汇编语言的系统应用。

These perceptions naturally led to the concept of designing a single universal computer that would be capable of doing both floating-point and decimal arithmetic, and therefore both scientific and business applications. Thus was born the concept of the IBM System/360 line of computers. Along with this came the idea of a programming language that could be used for both business and scientific applications. For good measure, features to support systems programming and list processing were thrown in. Therefore, the new language was to replace Fortran, COBOL, Lisp, and the systems applications of assembly language.

设计工作始于 1963 年 10 月，当时 IBM 和 SHARE 成立了 SHARE Fortran 项目的高级语言开发委员会。这个新委员会很快召开会议，并成立了一个名为 3 ⨯ 3 委员会的小组委员会，之所以这样命名，是因为委员会中有三名成员来自 IBM，三名成员来自 SHARE。3 ⨯ 3 委员会每隔一周开会三到四天来设计该语言。

The design effort began when IBM and SHARE formed the Advanced Language Development Committee of the SHARE Fortran Project in October 1963. This new committee quickly met and formed a subcommittee called the 3 ⨯ 3 Committee, so named because it had three members from IBM and three from SHARE. The 3 ⨯ 3 Committee met for three or four days every other week to design the language.

与 COBOL 的短程委员会一样，最初的设计计划在极短的时间内完成。显然，无论语言设计工作的范围如何，在 20 世纪 60 年代初期，人们普遍认为它可以在三个月内完成。PL/I 的第一个版本（当时名为 Fortran VI）应该在 12 月完成，即委员会成立后不到三个月。委员会两次成功地请求延期，将截止日期推迟到 1964 年 1 月，然后推迟到 2 月底。

As with the Short Range Committee for COBOL, the initial design was scheduled for completion in a remarkably short time. Apparently, regardless of the scope of a language design effort, in the early 1960s the prevailing belief was that it could be done in three months. The first version of PL/I, which was then named Fortran VI, was supposed to be completed by December, less than three months after the committee was formed. The committee pleaded successfully on two different occasions for extensions, moving the due date back to January and then to late February 1964.

最初的设计理念是，新语言将是 Fortran IV 的扩展，以保持兼容性，但这个目标很快就和 Fortran VI 这个名字一起被放弃了。直到 1965 年，这种语言被称为 NPL（新编程语言）。第一份关于 NPL 的报告是在 1964 年 3 月的 SHARE 会议上发表的。4 月份提供了更完整的描述，实际实现的版本于 1964 年 12 月（IBM，1964）由被选中负责实现的英国 IBM 赫斯利实验室的编译器小组发布。1965 年，名称更改为 PL/I，以避免 NPL 与英国国家物理实验室混淆。如果编译器是在英国以外开发的，那么名称可能仍然是 NPL。

The initial design concept was that the new language would be an extension of Fortran IV, maintaining compatibility, but that goal was dropped quickly along with the name Fortran VI. Until 1965, the language was known as NPL (New Programming Language). The first published report on NPL was given at the SHARE meeting in March 1964. A more complete description followed in April, and the version that would actually be implemented was published in December 1964 (IBM, 1964) by the compiler group at the IBM Hursley Laboratory in England, which was chosen to do the implementation. In 1965, the name was changed to PL/I to avoid the confusion of the name NPL with the National Physical Laboratory in England. If the compiler had been developed outside the United Kingdom, the name might have remained NPL.

也许对 PL/I 最好的一句话描述是，它包含了当时被认为是 ALGOL 60（递归和块结构）、Fortran IV（通过全局数据进行通信的单独编译）和 COBOL 60（数据结构、输入/输出和报告生成功能）的最佳部分，以及大量以某种方式拼凑在一起的新构造。由于 PL/I 不再是一种流行的语言，我们不会尝试（甚至不会简短地）讨论该语言的所有特性，甚至其最具争议的构造。相反，我们将提到该语言对编程语言知识库的一些贡献。

Perhaps the best single-sentence description of PL/I is that it included what were then considered the best parts of ALGOL 60 (recursion and block structure), Fortran IV (separate compilation with communication through global data), and COBOL 60 (data structures, input/output, and report-generating facilities), along with an extensive collection of new constructs, all somehow cobbled together. Because PL/I is no longer a popular language, we will not attempt, even briefly, to discuss all the features of the language, or even its most controversial constructs. Instead, we will mention some of the language’s contributions to the pool of knowledge of programming languages.

PL/I 是第一个具有以下功能的编程语言：

PL/I was the first programming language to have the following facilities:

• 程序允许创建并发执行的子程序。虽然这是一个好主意，但在 PL/I 中却发展得不太好。

• Programs were allowed to create concurrently executing subprograms. Although this was a good idea, it was poorly developed in PL/I.

• 可以检测和处理 23 种不同类型的异常或运行时错误。

• It was possible to detect and handle 23 different types of exceptions, or run-time errors.

• 允许子程序递归使用，但可以禁用该功能，从而允许非递归子程序更有效地链接。

• Subprograms were allowed to be used recursively, but the capability could be disabled, allowing more efficient linkage for nonrecursive subprograms.

• 指针被纳入为一种数据类型。

• Pointers were included as a data type.

• 可以引用数组的横截面。例如，可以引用矩阵的第三行，就好像它是一个一维数组一样。

• Cross-sections of arrays could be referenced. For example, the third row of a matrix could be referenced as if it were a single-dimensioned array.

对 PL/I 的任何评价都必须首先认识到设计工作的雄心壮志。回想​​起来，认为如此多的构造可以成功组合似乎有些天真。但是，必须承认当时语言设计经验很少，因此必须慎重判断。总体而言，PL/I 的设计基于这样的前提：任何有用且可以实现的构造都应该包括在内，而没有充分考虑程序员如何理解和有效使用这样的构造和特性集合。Edsger Dijkstra 在他的图灵奖演讲（Dijkstra，1972）中对 PL/I 的复杂性提出了最强烈的批评之一：“我完全看不出我们如何能够将不断增长的程序牢牢地控制在我们的智力控制之下，因为编程语言（请注意，这是我们的基本工具！）的复杂性已经脱离了我们的智力控制。”

Any evaluation of PL/I must begin by recognizing the ambitiousness of the design effort. In retrospect, it appears naive to think that so many constructs could have been combined successfully. However, that judgment must be tempered by acknowledging that there was little language design experience at the time. Overall, the design of PL/I was based on the premise that any construct that was useful and could be implemented should be included, with insufficient concern about how a programmer could understand and make effective use of such a collection of constructs and features. Edsger Dijkstra, in his Turing Award Lecture (Dijkstra, 1972), made one of the strongest criticisms of the complexity of PL/I: “I absolutely fail to see how we can keep our growing programs firmly within our intellectual grip when by its sheer baroqueness the programming language—our basic tool, mind you!—already escapes our intellectual control.”

除了由于规模大而产生的复杂性问题之外，PL/I 还存在许多现在被认为是设计不良的结构。其中包括指针、异常处理和并发性，尽管我们必须指出，在所有情况下，这些结构都没有出现在以前的任何语言中。

In addition to the problem with the complexity due to its large size, PL/I suffered from a number of what are now considered to be poorly designed constructs. Among these were pointers, exception handling, and concurrency, although we must point out that in all cases, these constructs had not appeared in any previous language.

从使用方面来看，PL/I 至少可以说是部分成功的。在 20 世纪 70 年代，它在商业和科学应用中都得到了广泛应用。当时，它还被广泛用作大学教学工具，主要有几种子集形式，例如 PL/C（Cornell，1977 年）和 PL/CS（Conway 和 Constable，1976 年）。

In terms of usage, PL/I must be considered at least a partial success. In the 1970s, it enjoyed significant use in both business and scientific applications. It was also widely used during that time as an instructional vehicle in colleges, primarily in several subset forms, such as PL/C (Cornell, 1977) and PL/CS (Conway and Constable, 1976).

以下是 PL/I 程序的一个示例：

The following is an example of a PL/I program:

/* PL/I PROGRAM EXAMPLE
 INPUT:   AN INTEGER, LISTLEN, WHERE LISTLEN IS LESS THAN
          100, FOLLOWED BY LISTLEN-INTEGER VALUES
 OUTPUT:  THE NUMBER OF INPUT VALUES THAT ARE GREATER THAN
          THE AVERAGE OF ALL INPUT VALUES */
PLIEX: PROCEDURE OPTIONS (MAIN);
  DECLARE INTLIST (1:99) FIXED.
  DECLARE (LISTLEN, COUNTER, SUM, AVERAGE, RESULT) FIXED;
  SUM = 0;
  RESULT = 0;
  GET LIST (LISTLEN);
  IF (LISTLEN > 0) & (LISTLEN < 100) THEN
    DO;
/* READ INPUT DATA INTO AN ARRAY AND COMPUTE THE SUM */
    DO COUNTER = 1 TO LISTLEN;
      GET LIST (INTLIST (COUNTER));
      SUM = SUM + INTLIST (COUNTER);
    END;
/* COMPUTE THE AVERAGE */
    AVERAGE = SUM / LISTLEN;
/* COUNT THE NUMBER OF VALUES THAT ARE > AVERAGE */
    DO COUNTER = 1 TO LISTLEN;
      IF INTLIST (COUNTER) > AVERAGE THEN
        RESULT = RESULT + 1;
    END;
/* PRINT RESULT */
    PUT SKIP LIST ('THE NUMBER OF VALUES > AVERAGE IS:');
    PUT LIST (RESULT);
    END;
ELSE
    PUT SKIP LIST ('ERROR-INPUT LIST LENGTH IS ILLEGAL');
END PLIEX;

/* PL/I PROGRAM EXAMPLE
 INPUT:   AN INTEGER, LISTLEN, WHERE LISTLEN IS LESS THAN
          100, FOLLOWED BY LISTLEN-INTEGER VALUES
 OUTPUT:  THE NUMBER OF INPUT VALUES THAT ARE GREATER THAN
          THE AVERAGE OF ALL INPUT VALUES */
PLIEX: PROCEDURE OPTIONS (MAIN);
  DECLARE INTLIST (1:99) FIXED.
  DECLARE (LISTLEN, COUNTER, SUM, AVERAGE, RESULT) FIXED;
  SUM = 0;
  RESULT = 0;
  GET LIST (LISTLEN);
  IF (LISTLEN > 0) & (LISTLEN < 100) THEN
    DO;
/* READ INPUT DATA INTO AN ARRAY AND COMPUTE THE SUM */
    DO COUNTER = 1 TO LISTLEN;
      GET LIST (INTLIST (COUNTER));
      SUM = SUM + INTLIST (COUNTER);
    END;
/* COMPUTE THE AVERAGE */
    AVERAGE = SUM / LISTLEN;
/* COUNT THE NUMBER OF VALUES THAT ARE > AVERAGE */
    DO COUNTER = 1 TO LISTLEN;
      IF INTLIST (COUNTER) > AVERAGE THEN
        RESULT = RESULT + 1;
    END;
/* PRINT RESULT */
    PUT SKIP LIST ('THE NUMBER OF VALUES > AVERAGE IS:');
    PUT LIST (RESULT);
    END;
ELSE
    PUT SKIP LIST ('ERROR-INPUT LIST LENGTH IS ILLEGAL');
END PLIEX;

APL（Brown 等人，1988 年）由 IBM 的 Kenneth E. Iverson 于 1960 年左右设计。它最初并非设计为一种可实现的编程语言，而是旨在成为描述计算机体系结构的载体。APL 最早出现在其得名之作《一种编程语言》（Iverson，1962 年）一书中。20 世纪 60 年代中期，IBM 开发了 APL 的第一个实现。

APL (Brown et al., 1988) was designed around 1960 by Kenneth E. Iverson at IBM. It was not originally designed to be an implemented programming language but rather was intended to be a vehicle for describing computer architecture. APL was first described in the book from which it gets its name, A Programming Language (Iverson, 1962). In the mid-1960s, the first implementation of APL was developed at IBM.

APL 具有大量强大的运算符，这些运算符是用大量符号指定的，这给实现者带来了问题。最初，APL 是通过 IBM 打印终端使用的。这些终端具有特殊的可选打印球，可提供该语言所需的奇数字符集。APL 具有如此多运算符的一个原因是它提供了大量数组上的单元操作。例如，任何矩阵的转置都用单个运算符完成。大量的运算符集合提供了非常高的表达能力，但也使 APL 程序难以阅读。因此，人们认为 APL 是一种最适合用于“一次性”编程的语言。尽管可以快速编写程序，但由于难以维护，因此在使用后应将其丢弃。

APL has a large number of powerful operators that are specified with a large number of symbols, which created a problem for implementors. Initially, APL was used through IBM printing terminals. These terminals had special optional print balls that provided the odd character set required by the language. One reason APL has so many operators is that it provides a large number of unit operations on arrays. For example, the transpose of any matrix is done with a single operator. The large collection of operators provides very high expressivity but also makes APL programs difficult to read. Therefore, people think of APL as a language that is best used for “throw-away” programming. Although programs can be written quickly, they should be discarded after use because they are difficult to maintain.

APL 已经存在了 55 年多，至今仍在使用，尽管使用范围并不广泛。此外，它自诞生以来并没有发生太大的变化。

APL has been around for over 55 years and is still used today, although not widely. Furthermore, it has not changed a great deal over its lifetime.

SNOBOL（发音为“snowball”；Griswold 等人，1971 年）由贝尔实验室的三个人于 20 世纪 60 年代初设计：DJ Farber、RE Griswold 和 IP Polonsky（Farber 等人，1964 年）。它是专门为文本处理而设计的。SNOBOL 的核心是一组用于字符串模式匹配的强大操作。SNOBOL 的早期应用之一是编写文本编辑器。由于 SNOBOL 的动态特性使其比其他语言慢，因此它不再用于此类程序。但是，SNOBOL 仍然是一种活跃且受支持的语言，可用于多个不同应用领域的各种文本处理任务。

SNOBOL (pronounced “snowball”; Griswold et al., 1971) was designed in the early 1960s by three people at Bell Laboratories: D. J. Farber, R. E. Griswold, and I. P. Polonsky (Farber et al., 1964). It was designed specifically for text processing. The heart of SNOBOL is a collection of powerful operations for string pattern matching. One of the early applications of SNOBOL was for writing text editors. Because the dynamic nature of SNOBOL makes it slower than alternative languages, it is no longer used for such programs. However, SNOBOL is still a live and supported language that is used for a variety of text-processing tasks in several different application areas.

1962 年至 1964 年间，两位挪威人 Kristen Nygaard 和 Ole-Johan Dahl 在奥斯陆的挪威计算中心 (NCC) 开发了 SIMULA I 语言。他们主要对使用计算机进行模拟感兴趣，但也从事运筹学工作。SIMULA I 专为系统模拟而设计，并于 1964 年底在 UNIVAC 1107 计算机上首次实现。

Two Norwegians, Kristen Nygaard and Ole-Johan Dahl, developed the language SIMULA I between 1962 and 1964 at the Norwegian Computing Center (NCC) in Oslo. They were primarily interested in using computers for simulation but also worked in operations research. SIMULA I was designed exclusively for system simulation and was first implemented in late 1964 on a UNIVAC 1107 computer.

SIMULA I 实现完成后，Nygaard 和 Dahl 开始努力扩展该语言，添加新功能并修改一些现有结构，以使该语言适用于通用应用程序。这项工作的成果是 SIMULA 67，其设计于 1967 年 3 月首次公开展示（Dahl 和 Nygaard，1967 年）。我们将仅讨论 SIMULA 67，尽管 SIMULA 67 中的一些有趣功能也存在于 SIMULA I 中。

As soon as the SIMULA I implementation was completed, Nygaard and Dahl began efforts to extend the language by adding new features and modifying some existing constructs in order to make the language useful for general-purpose applications. The result of this work was SIMULA 67, whose design was first presented publicly in March 1967 (Dahl and Nygaard, 1967). We will discuss only SIMULA 67, although some of the features of interest in SIMULA 67 are also in SIMULA I.

SIMULA 67 是 ALGOL 60 的扩展，它采用了该语言的块结构和控制语句。ALGOL 60（以及当时的其他语言）在模拟应用方面的主要缺陷在于其子程序的设计。模拟需要允许子程序在之前停止的位置重新启动。具有这种控制的子程序称为协同程序，因为调用者和被调用子程序彼此之间具有某种平等关系，而不是大多数命令式语言中严格的主/从关系。

SIMULA 67 is an extension of ALGOL 60, taking both block structure and the control statements from that language. The primary deficiency of ALGOL 60 (and other languages at that time) for simulation applications was the design of its subprograms. Simulation requires subprograms that are allowed to restart at the position where they previously stopped. Subprograms with this kind of control are known as coroutines because the caller and called subprograms have a somewhat equal relationship with each other, rather than the rigid master/slave relationship they have in most imperative languages.

为了在 SIMULA 67 中提供对协程的支持，开发了类构造。这是一个重要的发展，因为数据抽象的概念始于它，而数据抽象为面向对象编程提供了基础。

To provide support for coroutines in SIMULA 67, the class construct was developed. This was an important development because the concept of data abstraction began with it and data abstraction provides the foundation for object-oriented programming.

有趣的是，数据抽象这一重要概念直到 1972 年才得到发展并归因于类构造，当时Hoare (1972)认识到了这种联系。

It is interesting to note that the important concept of data abstraction was not developed and attributed to the class construct until 1972, when Hoare (1972) recognized the connection.

1962 年 ALGOL 60 修订报告发布后，ALGOL 家族的开发并未结束，尽管六年后才发布下一个设计版本。最终的语言 ALGOL 68（van Wijngaarden 等人，1969 年）与其前身截然不同。

The development of the ALGOL family did not end when the revised report on ALGOL 60 appeared in 1962, although it was six years until the next design iteration was published. The resulting language, ALGOL 68 (van Wijngaarden et al., 1969), was dramatically different from its predecessor.

ALGOL 68 最有趣的创新之一是其主要设计标准之一：正交性。回想一下我们在第1章 中对正交性的讨论。正交性的使用为 ALGOL 68 带来了几个创新特性，其中之一将在下一节中介绍。

One of the most interesting innovations of ALGOL 68 was one of its primary design criteria: orthogonality. Recall our discussion of orthogonality in Chapter 1. The use of orthogonality resulted in several innovative features of ALGOL 68, one of which is described in the following section.

ALGOL 68 正交性的一个重要结果是它包含了用户定义的数据类型。早期的语言（例如 Fortran）仅包含一些基本数据结构。PL/I 包含的数据结构数量更多，这使得它更难学习和实现，但它仍然无法为每种需求提供合适的数据结构。

One important result of orthogonality in ALGOL 68 was its inclusion of user-defined data types. Earlier languages, such as Fortran, included only a few basic data structures. PL/I included a larger number of data structures, which made it harder to learn and difficult to implement, but it still could not provide an appropriate data structure for every need.

ALGOL 68 处理数据结构的方法是提供一些原始类型和结构，并允许用户组合这些原始类型来定义大量不同的结构。这种用户定义数据类型的规定在一定程度上延续到了此后设计的所有主要命令式语言中。用户定义数据类型很有价值，因为它们允许用户设计非常贴合特定问题的数据抽象。第6章 讨论了数据类型的各个方面。

The approach of ALGOL 68 to data structures was to provide a few primitive types and structures and allow the user to combine those primitives to define a large number of different structures. This provision for user-defined data types was carried over to some extent into all of the major imperative languages designed since then. User-defined data types are valuable because they allow the user to design data abstractions that fit particular problems very closely. All aspects of data types are discussed in Chapter 6.

作为数据类型领域的另一项首创，ALGOL 68 引入了一种动态数组，该数组将 在第5章中被称为隐式堆动态。动态数组是在声明中未指定下标边界的数组。对动态数组的赋值会导致分配所需的存储空间。在 ALGOL 68 中，动态数组称为数组。 flex

As another first in the area of data types, ALGOL 68 introduced the kind of dynamic arrays that will be termed implicit heap-dynamic in Chapter 5. A dynamic array is one in which the declaration does not specify subscript bounds. Assignments to a dynamic array cause allocation of required storage. In ALGOL 68, dynamic arrays are called flex arrays.

ALGOL 68 包含大量以前未曾使用过的功能。它对正交性的使用（有些人可能认为有点过度）却是革命性的。

ALGOL 68 includes a significant number of features that had not been previously used. Its use of orthogonality, which some may argue was overdone, was nevertheless revolutionary.

然而，ALGOL 68 重蹈了 ALGOL 60 的覆辙，这也是其流行度有限的一个重要因素。该语言使用一种优雅简洁但又不为人知的元语言来描述。在阅读语言描述文档（van Wijngaarden et al., 1969）之前，必须先学习一种新的元语言，即 van Wijngaarden 语法，它比 BNF 复杂得多。更糟糕的是，设计者发明了一套词汇来解释语法和语言。例如，关键字被称为indicants，子串提取被称为trimming，子程序执行的过程被称为coercion of deproceduring，它可能是meek、firm或其他什么。

ALGOL 68 repeated one of the sins of ALGOL 60, however, and it was an important factor in its limited popularity. The language was described using an elegant and concise but also unknown metalanguage. Before one could read the language-describing document (van Wijngaarden et al., 1969), he or she had to learn the new metalanguage, called van Wijngaarden grammars, which were far more complex than BNF. To make matters worse, the designers invented a collection of words to explain the grammar and the language. For example, keywords were called indicants, substring extraction was called trimming, and the process of a subprogram execution was called a coercion of deproceduring, which might be meek, firm, or something else.

很自然地，我们会将 PL/I 的设计与 ALGOL 68 的设计进行对比，因为它们的出现时间只相隔了几年。ALGOL 68 通过正交性原则实现了可写性：一些原始概念和一些组合机制的不受限制的使用。PL/I 通过包含大量固定结构实现了可写性。ALGOL 68 扩展了 ALGOL 60 的优雅简洁性，而 PL/I 只是将几种语言的功能组合在一起以实现其目标。当然，必须记住，PL/I 的目标是为广泛的问题提供统一的工具，而 ALGOL 68 只针对一个类别：科学应用。

It is natural to contrast the design of PL/I with that of ALGOL 68, because they appeared only a few years apart. ALGOL 68 achieved writability by the principle of orthogonality: a few primitive concepts and the unrestricted use of a few combining mechanisms. PL/I achieved writability by including a large number of fixed constructs. ALGOL 68 extended the elegant simplicity of ALGOL 60, whereas PL/I simply threw together the features of several languages to attain its goals. Of course, it must be remembered that the goal of PL/I was to provide a unified tool for a broad class of problems, whereas ALGOL 68 was targeted to a single class: scientific applications.

PL/I 比 ALGOL 68 获得了更大的认可，这主要归功于 IBM 的推广努力以及理解和实施方面的问题ALGOL 68。实现对两者来说都是一个难题，但 PL/I 拥有 IBM 的资源，可以用于构建编译器。ALGOL 68 却没有这样的恩人。

PL/I achieved far greater acceptance than ALGOL 68, due largely to IBM’s promotional efforts and the problems of understanding and implementing ALGOL 68. Implementation was a difficult problem for both, but PL/I had the resources of IBM to apply to building a compiler. ALGOL 68 enjoyed no such benefactor.

与 Pascal 一样，C 语言对之前已知的语言特性贡献不大，但它在很长一段时间内得到了广泛应用。尽管最初设计用于系统编程，但 C 语言非常适合各种应用程序。

Like Pascal, C contributed little to the previously known collection of language features, but it has been widely used over a long period of time. Although originally designed for systems programming, C is well suited for a wide variety of applications.

/* C Example Program
 Input:  An integer, listlen, where listlen is less than
         100, followed by listlen-integer values
 Output: The number of input values that are greater than
         the average of all input values */
int main (){
  int intlist[99], listlen, counter, sum, average, result;
  sum = 0;
  result = 0;
  scanf("%d", &listlen);
  if ((listlen > 0) && (listlen < 100)) {
/* Read input into an array and compute the sum */
    for (counter = 0; counter < listlen; counter++) {
     scanf("%d", &intlist[counter]);
     sum += intlist[counter];
    }
/* Compute the average */
    average = sum / listlen;
/* Count the input values that are > average */
     for  (counter = 0; counter < listlen; counter++)
       if  (intlist[counter] > average) result++;
/* Print result */
    printf("Number of values > average is:%d\n", result);
  }
  else
    printf("Error-input list length is not legal\n");
}

/* C Example Program
 Input:  An integer, listlen, where listlen is less than
         100, followed by listlen-integer values
 Output: The number of input values that are greater than
         the average of all input values */
int main (){
  int intlist[99], listlen, counter, sum, average, result;
  sum = 0;
  result = 0;
  scanf("%d", &listlen);
  if ((listlen > 0) && (listlen < 100)) {
/* Read input into an array and compute the sum */
    for (counter = 0; counter < listlen; counter++) {
     scanf("%d", &intlist[counter]);
     sum += intlist[counter];
    }
/* Compute the average */
    average = sum / listlen;
/* Count the input values that are > average */
     for  (counter = 0; counter < listlen; counter++)
       if  (intlist[counter] > average) result++;
/* Print result */
    printf("Number of values > average is:%d\n", result);
  }
  else
    printf("Error-input list length is not legal\n");
}

20 世纪 70 年代初，艾克斯-马赛大学人工智能小组的 Alain Colmerauer 和 Phillippe Roussel 与爱丁堡大学人工智能系的 Robert Kowalski 共同开发了 Prolog 的基本设计。Prolog 的主要组成部分是指定谓词演算命题的方法和受限形式的解析的实现。第16章 介绍了谓词演算和解析。第一个 Prolog 解释器于 1972 年在马赛开发。所实现的语言版本在Roussel (1975)中进行了描述。Prolog 这个名字来自编程逻辑。

During the early 1970s, Alain Colmerauer and Phillippe Roussel in the Artificial Intelligence Group at the University of Aix-Marseille, together with Robert Kowalski of the Department of Artificial Intelligence at the University of Edinburgh, developed the fundamental design of Prolog. The primary components of Prolog are a method for specifying predicate calculus propositions and an implementation of a restricted form of resolution. Both predicate calculus and resolution are described in Chapter 16. The first Prolog interpreter was developed at Marseille in 1972. The version of the language that was implemented is described in Roussel (1975). The name Prolog is from programming logic.

Prolog 程序由语句集合组成。Prolog 只有几种语句，但它们可能很复杂。

Prolog programs consist of collections of statements. Prolog has only a few kinds of statements, but they can be complex.

Prolog 的一个常见用途是作为一种智能数据库。此应用程序为讨论 Prolog 语言提供了一个简单的框架。

One common use of Prolog is as a kind of intelligent database. This application provides a simple framework for discussing the Prolog language.

Prolog 程序的数据库由两种类型的语句组成：事实和规则。以下是事实语句的示例：

The database of a Prolog program consists of two kinds of statements: facts and rules. The following are examples of fact statements:

mother(joanne, jake).
father(vern, joanne).

mother(joanne, jake).
father(vern, joanne).

这些表明joanne是mother的jake，并且vern是father的joanne。

These state that joanne is the mother of jake, and vern is the father of joanne.

规则语句的示例为

An example of a rule statement is

grandparent(X, Z) :- parent(X, Y), parent(Y, Z).

grandparent(X, Z) :- parent(X, Y), parent(Y, Z).

这表明，如果 是的且是的父级，X则可推断 是grandparent的，对于变量 、 和 的某些特定值。ZXparentYYZXYZ

This states that it can be deduced that X is the grandparent of Z if it is true that X is the parent of Y and Y is the parent of Z, for some specific values for the variables X, Y, and Z.

Prolog 数据库可以用目标语句进行交互式查询，例如

The Prolog database can be interactively queried with goal statements, an example of which is

father(bob, darcie).

father(bob, darcie).

这询问 是否bob是father的darcie。当这样的查询或目标呈现给 Prolog 系统时，它会使用其解析过程来尝试确定语句的真实性。如果它可以得出结论，即目标为真，则显示“真”。如果它无法证明这一点，则显示“假”。

This asks if bob is the father of darcie. When such a query, or goal, is presented to the Prolog system, it uses its resolution process to attempt to determine the truth of the statement. If it can conclude that the goal is true, it displays “true.” If it cannot prove it, it displays “false.”

20 世纪 80 年代，有一小部分计算机科学家认为，逻辑编程是摆脱命令式语言复杂性以及开发大量可靠软件的巨大问题的最佳希望。然而，到目前为止，逻辑编程尚未得到广泛应用的主要原因有两个。首先，与其他一些非命令式方法一样，迄今为止，用逻辑语言编写的程序已被证明相对于等效的命令式程序效率极低。其次，人们已经确定，它只对少数几个相对较小的应用领域有效：某些类型的数据库管理系统和某些 AI 领域。

In the 1980s, there was a relatively small group of computer scientists who believed that logic programming provided the best hope for escaping from the complexity of imperative languages, and also from the enormous problem of producing the large amount of reliable software that was needed. So far, however, there are two major reasons why logic programming has not become more widely used. First, as with some other nonimperative approaches, programs written in logic languages thus far have proven to be highly inefficient relative to equivalent imperative programs. Second, it has been determined that it is an effective approach for only a few relatively small areas of application: certain kinds of database management systems and some areas of AI.

Prolog 有一种支持面向对象编程的方言：Prolog++（Moss，1994 ）。第16章 将更详细地介绍逻辑编程和 Prolog 。

There is a dialect of Prolog that supports object-oriented programming: Prolog++ (Moss, 1994). Logic programming and Prolog are described in greater detail in Chapter 16.

Ada 语言是为国防部 (DoD) 开发的，因此其计算环境的状态对于确定其形式至关重要。到 1974 年，国防部一半以上的计算机应用程序都是嵌入式系统。嵌入式系统是指将计算机硬件嵌入到它控制或提供服务的设备中的系统。软件成本迅速上升，主要是因为系统越来越复杂。国防部项目使用了 450 多种不同的编程语言，但没有一种被国防部标准化。每个国防承包商都可以为每个合同定义一种新的和不同的语言。12由于语言的激增，应用软件很少被重复使用。此外，没有创建软件开发工具（因为它们通常依赖于语言）。使用了很多语言，但没有一种真正适合嵌入式系统应用程序。出于这些原因，1974 年，陆军、海军和空军各自独立提出开发一种用于嵌入式系统的高级语言。

The Ada language was developed for the Department of Defense (DoD), so the state of their computing environment was instrumental in determining its form. By 1974, over half of the applications of computers in DoD were embedded systems. An embedded system is one in which the computer hardware is embedded in the device it controls or for which it provides services. Software costs were rising rapidly, primarily because of the increasing complexity of systems. More than 450 different programming languages were in use for DoD projects, and none of them was standardized by DoD. Every defense contractor could define a new and different language for every contract.12 Because of this language proliferation, application software was rarely reused. Furthermore, no software development tools were created (because they are usually language dependent). A great many languages were in use, but none was actually suitable for embedded systems applications. For these reasons, in 1974, the Army, Navy, and Air Force each independently proposed the development of a single high-level language for embedded systems.

注意到这一广泛的兴趣，国防研究与工程部主任马尔科姆·柯里于 1975 年 1 月成立了高阶语言工作组 (HOLWG)，最初由空军中校威廉·惠特克领导。HOLWG 的代表来自所有军种，并与英国、法国和当时的西德保持联络。其最初的章程是做以下事情：

Noting this widespread interest, in January 1975, Malcolm Currie, director of Defense Research and Engineering, formed the High-Order Language Working Group (HOLWG), initially headed by Lt. Col. William Whitaker of the Air Force. The HOLWG had representatives from all of the military services and liaisons with Great Britain, France, and what was then West Germany. Its initial charter was to do the following:

• 确定新国防部高级语言的要求。

• Identify the requirements for a new DoD high-level language.

• 评估现有语言以确定是否存在可行的候选者。

• Evaluate existing languages to determine whether there was a viable candidate.

• 建议采用或实施一组最少的编程语言。

• Recommend adoption or implementation of a minimal set of programming languages.

1975 年 4 月，HOLWG 为新语言制作了 Strawman 需求文档（国防部，1975a）。该文档分发给各军种、联邦机构、选定的工业和大学代表以及欧洲的相关方。

In April 1975, the HOLWG produced the Strawman requirements document for the new language (Department of Defense, 1975a). This was distributed to military branches, federal agencies, selected industrial and university representatives, and interested parties in Europe.

继 Strawman 文件之后，1975 年 8 月又发布了 Woodenman 文件（国防部，1975b ）， 1976 年 1 月又发布了Tinman 文件（国防部，1976 ），1977 年 1 月又发布了 Ironman 文件（国防部，1977），最后在 1978 年 6 月又发布了 Steelman 文件（国防部，1978 ）。

The Strawman document was followed by Woodenman (Department of Defense, 1975b) in August 1975, Tinman (Department of Defense, 1976) in January 1976, Ironman (Department of Defense, 1977) in January 1977, and finally Steelman (Department of Defense, 1978) in June 1978.

经过漫长的选拔过程，众多提交的语言方案最终缩小到四个入围者，所有方案均基于 Pascal。1979 年 5 月，Cii Honeywell/Bull 语言设计方案从四个入围者中脱颖而出，成为最终的设计方案。Cii Honeywell/Bull 设计团队来自法国，是四支队伍中唯一的外国参赛者，由 Jean Ichbiah 领导。

After a tedious process, the many submitted proposals for the language were narrowed down to four finalists, all of which were based on Pascal. In May 1979, the Cii Honeywell/Bull language design proposal was chosen from the four finalists as the design that would be used. The Cii Honeywell/Bull design team in France, the only foreign competitor among the final four, was led by Jean Ichbiah.

1979 年春，海军物资司令部的杰克·库珀 (Jack Cooper) 建议将新语言命名为 Ada，该名称随后被采纳。该名称是为了纪念奥古斯塔·艾达·拜伦 (Augusta Ada Byron，1815-1851 年)，她是洛夫莱斯伯爵夫人、数学家，也是诗人拜伦勋爵的女儿。她被公认为世界上第一位程序员。她与查尔斯·巴贝奇合作开发了他的机械计算机、差分机和分析机，为多个数值过程编写了程序。

In the spring of 1979, Jack Cooper of the Navy Materiel Command recommended the name for the new language, Ada, which was then adopted. The name commemorates Augusta Ada Byron (1815–1851), countess of Lovelace, mathematician, and daughter of poet Lord Byron. She is generally recognized as being the world’s first programmer. She worked with Charles Babbage on his mechanical computers, the Difference and Analytical Engines, writing programs for several numerical processes.

ACM 在SIGPLAN 通告( ACM, 1979 )中公布了 Ada 的设计和基本原理，并分发给了 10,000 多名读者。1979 年 10 月，在波士顿举行了一次公开测试和评估会议，来自美国和欧洲的 100 多个组织的代表参加了会议。截至 11 月，已收到来自 15 个不同国家的 500 多份语言报告。大多数报告建议进行小幅修改，而不是进行大幅更改和彻底拒绝。基于语言报告，需求规范的下一个版本，即 Stoneman 文档 ( Department of Defense, 1980 )，于 1980 年 2 月发布。

The design and the rationale for Ada were published by ACM in its SIGPLAN Notices (ACM, 1979) and distributed to a readership of more than 10,000 people. A public test and evaluation conference was held in October 1979 in Boston, with representatives from over 100 organizations from the United States and Europe. By November, more than 500 language reports had been received from 15 different countries. Most of the reports suggested small modifications rather than drastic changes and outright rejections. Based on the language reports, the next version of the requirements specification, the Stoneman document (Department of Defense, 1980), was released in February 1980.

1980 年 7 月，语言设计修订版完成，并被接受为 MIL-STD 1815，即标准Ada 语言参考手册。之所以选择 1815 这个数字，是因为这是 Augusta Ada Byron 出生的年份。Ada语言参考手册的另一个修订版于 1982 年 7 月发布。1983 年，美国国家标准协会对 Ada 进行了标准化。Goos和 Hartmanis (1983)描述了这个“最终”官方版本。Ada 语言设计随后被冻结了至少五年。

A revised version of the language design was completed in July 1980 and was accepted as MIL-STD 1815, the standard Ada Language Reference Manual. The number 1815 was chosen because it was the year of the birth of Augusta Ada Byron. Another revised version of the Ada Language Reference Manual was released in July 1982. In 1983, the American National Standards Institute standardized Ada. This “final” official version is described in Goos and Hartmanis (1983). The Ada language design was then frozen for a minimum of five years.

本小节简要描述了 Ada 语言的四个主要贡献。

This subsection briefly describes four of the major contributions of the Ada language.

Ada 语言中的包提供了封装数据对象、数据类型规范和过程的方法。这反过来又为在程序设计中使用数据抽象提供了支持。

Packages in the Ada language provide the means for encapsulating data objects, specifications for data types, and procedures. This, in turn, provides the support for the use of data abstraction in program design.

Ada 语言包含大量异常处理功能，这使得程序员在检测到各种异常或运行时错误后能够获得控制权。

The Ada language includes extensive facilities for exception handling, which allow the programmer to gain control after any one of a wide variety of exceptions, or run-time errors, has been detected.

在 Ada 中，程序单元可以是通用的。例如，可以编写一个排序过程，使用未指定的类型对要排序的数据进行排序。这种通用过程必须先针对指定类型进行实例化，然后才能使用，这可以通过一条语句来完成，该语句使编译器生成具有给定类型的过程版本。这种通用单元的可用性增加了程序员可以重用（而不是重复）的程序单元的范围。

Program units can be generic in Ada. For example, it is possible to write a sort procedure that uses an unspecified type for the data to be sorted. Such a generic procedure must be instantiated for a specified type before it can be used, which is done with a statement that causes the compiler to generate a version of the procedure with the given type. The availability of such generic units increases the range of program units that might be reused, rather than duplicated, by programmers.

Ada 语言还利用会合机制支持并发执行特殊程序单元（称为任务）。会合是一种任务间通信和同步方法的名称。

The Ada language also provides for concurrent execution of special program units, named tasks, using the rendezvous mechanism. Rendezvous is the name of a method of intertask communication and synchronization.

在设计 Ada 语言时需要考虑的最重要的方面可能是：

Perhaps the most important aspects of the design of the Ada language to consider are the following:

• 由于设计具有竞争性，因此参与没有限制。

• Because the design was competitive, there were no limits on participation.

• Ada 语言体现了 20 世纪 70 年代末软件工程和语言设计的大部分概念。尽管有人可能会质疑整合这些功能的实际方法，以及在一种语言中包含如此多功能是否明智，但大多数人都认为这些功能很有价值。

• The Ada language embodies most of the concepts of software engineering and language design of the late 1970s. Although one can question the actual approaches used to incorporate these features, as well as the wisdom of including such a large number of features in a language, most agree that the features are valuable.

• 虽然大多数人没有预料到，但开发 Ada 语言的编译器是一项艰巨的任务。直到 1985 年，即语言设计完成近四年后，才开始出现真正可用的 Ada 编译器。

• Although most people did not anticipate it, the development of a compiler for the Ada language was a difficult task. Only in 1985, almost four years after the language design was completed, did truly usable Ada compilers begin to appear.

在 Ada 问世的最初几年，人们最严厉的批评就是它太过庞大和复杂。特别是，Hoare (1981)指出，它不适用于任何对可靠性要求很高的应用程序，而 Ada 正是为这类应用程序而设计的。另一方面，其他人称赞它是当时语言设计的典范。事实上，就连 Hoare 最终也软化了他对 Ada 的看法。

The most serious criticism of Ada in its first few years was that it was too large and too complex. In particular, Hoare (1981) stated that it should not be used for any application where reliability is critical, which is precisely the type of application for which it was designed. On the other hand, others have praised it as the epitome of language design for its time. In fact, even Hoare eventually softened his view of the language.

以下是 Ada 程序的示例：

The following is an example of an Ada program:

-- Ada Example Program
-- Input:   An integer, List_Len, where List_Len is less
--          than 100, followed by List_Len-integer values
-- Output:  The number of input values that are greater
--          than the average of all input values
with Ada.Text_IO, Ada.Integer.Text_IO;
use Ada.Text_IO, Ada.Integer.Text_IO;
procedure Ada_Ex is
  type Int_List_Type is array (1..99) of Integer;
  Int_List : Int_List_Type;
  List_Len, Sum, Average, Result : Integer;
begin
  Result:= 0;
  Sum := 0;
  Get (List_Len);
  if (List_Len > 0) and (List_Len < 100) then
-- Read input data into an array and compute the sum
    for Counter := 1 .. List_Len loop
      Get (Int_List(Counter));
      Sum := Sum + Int_List(Counter);
    end loop;
-- Compute the average
    Average := Sum / List_Len;
-- Count the number of values that are > average
    for Counter := 1 .. List_Len loop
      if Int_List(Counter) > Average then
        Result:= Result+ 1;
      end if;
    end loop;
-- Print result
    Put ("The number of values > average is:");
    Put (Result);
    New_Line;
  else
    Put_Line ("Error-input list length is not legal");
  end if;
end Ada_Ex;

-- Ada Example Program
-- Input:   An integer, List_Len, where List_Len is less
--          than 100, followed by List_Len-integer values
-- Output:  The number of input values that are greater
--          than the average of all input values
with Ada.Text_IO, Ada.Integer.Text_IO;
use Ada.Text_IO, Ada.Integer.Text_IO;
procedure Ada_Ex is
  type Int_List_Type is array (1..99) of Integer;
  Int_List : Int_List_Type;
  List_Len, Sum, Average, Result : Integer;
begin
  Result:= 0;
  Sum := 0;
  Get (List_Len);
  if (List_Len > 0) and (List_Len < 100) then
-- Read input data into an array and compute the sum
    for Counter := 1 .. List_Len loop
      Get (Int_List(Counter));
      Sum := Sum + Int_List(Counter);
    end loop;
-- Compute the average
    Average := Sum / List_Len;
-- Count the number of values that are > average
    for Counter := 1 .. List_Len loop
      if Int_List(Counter) > Average then
        Result:= Result+ 1;
      end if;
    end loop;
-- Print result
    Put ("The number of values > average is:");
    Put (Result);
    New_Line;
  else
    Put_Line ("Error-input list length is not legal");
  end if;
end Ada_Ex;

以下段落简要介绍了 Ada 95 的两个最重要的新功能。在本书的其余部分，当需要区分两个版本时，我们将使用名称 Ada 83 表示原始版本，使用 Ada 95（其实际名称）表示后续版本。在讨论两个版本共有的语言功能时，我们将使用名称 Ada。Ada 95 标准语言在ARM（1995）中定义。

Two of the most important new features of Ada 95 are described briefly in the following paragraphs. In the remainder of the book, we will use the name Ada 83 for the original version and Ada 95 (its actual name) for the later version when it is important to distinguish between the two versions. In discussions of language features common to both versions, we will use the name Ada. The Ada 95 standard language is defined in ARM (1995).

Ada 83 的类型派生机制在 Ada 95 中得到扩展，允许向从基类继承的组件添加新组件。这提供了继承，这是面向对象编程语言的关键要素。子程序调用与子程序定义的动态绑定是通过子程序调度实现的，子程序调度基于通过类范围类型的派生类型的标签值。此功能提供了多态性，这是面向对象编程的另一个主要功能。

The type derivation mechanism of Ada 83 is extended in Ada 95 to allow adding new components to those inherited from a base class. This provides for inheritance, a key ingredient in object-oriented programming languages. Dynamic binding of subprogram calls to subprogram definitions is accomplished through subprogram dispatching, which is based on the tag value of derived types through classwide types. This feature provides for polymorphism, another principal feature of object-oriented programming.

Ada 83 的会合机制仅提供了一种在并发进程之间共享数据的繁琐且低效的方法。有必要引入一项新任务来控制对共享数据的访问。Ada 95 的受保护对象提供了一种有吸引力的替代方案。共享数据封装在一个语法结构中，该结构控制对数据的所有访问，无论是通过会合还是通过子程序调用。

The rendezvous mechanism of Ada 83 provided only a cumbersome and inefficient means of sharing data among concurrent processes. It was necessary to introduce a new task to control access to the shared data. The protected objects of Ada 95 offer an attractive alternative to this. The shared data is encapsulated in a syntactic structure that controls all access to the data, either by rendezvous or by subprogram call.

人们普遍认为，Ada 95 的普及度下降是因为美国国防部不再要求在军事软件系统中使用 Ada 95。当然，还有其他因素阻碍了它的普及度。其中最重要的是 C++ 在面向对象编程方面的广泛接受，而这发生在 Ada 95 发布之前。

It is widely believed that the popularity of Ada 95 suffered because the Department of Defense stopped requiring its use in military software systems. There were, of course, other factors that hindered its growth in popularity. Most important among these was the widespread acceptance of C++ for object-oriented programming, which occurred before Ada 95 was released.

Ada 2005 对 Ada 95 进行了一些添加。其中包括与 Java 类似的接口、对调度算法的更多控制以及同步接口。

There were several additions to Ada 95 to get Ada 2005. Among these were interfaces, similar to those of Java, more control of scheduling algorithms, and synchronized interfaces.

Ada 广泛应用于商用和国防航空电子、空中交通管制、铁路运输以及其他领域。

Ada is widely used in both commercial and defense avionics, air traffic control, and rail transportation, as well as in other areas.

导致 Smalltalk 开发的概念源自 20 世纪 60 年代末犹他大学 Alan Kay 的博士论文（Kay, 1969）。Kay 具有非凡的远见，预测了未来将出现功能强大的台式计算机。回想一下，第一个微型计算机系统直到 20 世纪 70 年代中期才上市，它们与 Kay 设想的机器只有一点点关系，这些机器每秒可以执行一百万条或更多的指令，并包含几兆字节的内存。这种以工作站形式出现的机器直到 20 世纪 80 年代初才广泛普及。

The concepts that led to the development of Smalltalk originated in the Ph.D. dissertation work of Alan Kay in the late 1960s at the University of Utah (Kay, 1969). Kay had the remarkable foresight to predict the future availability of powerful desktop computers. Recall that the first microcomputer systems were not marketed until the mid-1970s, and they were only remotely related to the machines envisioned by Kay, which were seen to execute a million or more instructions per second and contain several megabytes of memory. Such machines, in the form of workstations, became widely available only in the early 1980s.

Kay 认为台式计算机将由非程序员使用，因此需要非常强大的人机界面功能。20 世纪 60 年代后期的计算机主要是面向批处理的，仅供专业程序员和科学家使用。Kay 认为，要供非程序员使用，计算机必须具有高度交互性，并在其用户界面中使用复杂的图形。一些图形概念来自 Seymour Papert 的 LOGO 经验，其中图形用于帮助儿童使用计算机（Papert，1980 年）。

Kay believed that desktop computers would be used by nonprogrammers and thus would need very powerful human-interfacing capabilities. The computers of the late 1960s were largely batch oriented and were used exclusively by professional programmers and scientists. For use by nonprogrammers, Kay determined, a computer would have to be highly interactive and use sophisticated graphics in its user interface. Some of the graphics concepts came from the LOGO experience of Seymour Papert, in which graphics were used to aid children in the use of computers (Papert, 1980).

Kay 最初设想了一个他称之为 Dynabook 的系统，该系统旨在成为通用信息处理器。该系统部分基于他曾参与设计的 Flex 语言。Flex 主要基于 SIMULA 67。Dynabook 使用了典型办公桌的范例，办公桌上有许多纸张，有些纸张被部分覆盖。最上面的纸张通常是关注的焦点，其他纸张则暂时失焦。Dynabook 的显示屏将模拟这一场景，使用屏幕窗口来表示桌面上的各种纸张。用户可以通过击键和用手指触摸屏幕与这样的显示屏进行交互。在 Dynabook 的初步设计为他赢得了博士学位后，Kay 的目标变成了看到这样一台机器的建造。

Kay originally envisioned a system he called Dynabook, which was meant to be a general information processor. It was based in part on the Flex language, which he had helped design. Flex was based primarily on SIMULA 67. Dynabook used the paradigm of the typical desk, on which there are a number of papers, some partially covered. The top sheet is often the focus of attention, with the others temporarily out of focus. The display of Dynabook would model this scene, using screen windows to represent various sheets of paper on the desktop. The user would interact with such a display both through keystrokes and by touching the screen with his or her fingers. After the preliminary design of Dynabook earned him a Ph.D., Kay’s goal became to see such a machine constructed.

Kay 进入了施乐帕洛阿尔托研究中心 (Xerox PARC)，并提出了关于 Dynabook 的想法。这使他在那里就业，并随后在施乐成立了学习研究小组。该小组的第一项任务是设计一种语言来支持 Kay 的编程范式，并将其实现在当时最好的个人计算机上。这些努力的结果是产生了一种“临时” Dynabook，由施乐 Alto 工作站和 Smalltalk-72 软件组成。它们共同构成了一个用于进一步开发的研究工具。使用该系统进行了许多研究项目，包括几项向儿童教授编程的实验。随着实验的进行，计算机得到了进一步的发展，产生了一系列语言，以 Smalltalk-80 结尾。随着语言的发展，它所依赖的硬件的功能也随之增强。到 1980 年，该语言和施乐硬件都几乎符合 Alan Kay 早期的愿景。

Kay found his way to the Xerox Palo Alto Research Center (Xerox PARC) and presented his ideas on Dynabook. This led to his employment there and the subsequent birth of the Learning Research Group at Xerox. The first charge of the group was to design a language to support Kay’s programming paradigm and implement it on the best personal computer then available. These efforts resulted in an “Interim” Dynabook, consisting of a Xerox Alto workstation and Smalltalk-72 software. Together, they formed a research tool for further development. A number of research projects were conducted with this system, including several experiments to teach programming to children. Along with the experiments came further developments, leading to a sequence of languages that ended with Smalltalk-80. As the language grew, so did the power of the hardware on which it resided. By 1980, both the language and the Xerox hardware nearly matched the early vision of Alan Kay.

Smalltalk 世界只由对象组成，从整数常量到大型复杂软件系统。 Smalltalk 中的所有计算都采用相同的统一技术：向对象发送消息以调用其方法之一。对消息的回复是一个对象，它要么返回请求的信息，要么只是通知发送者请求的处理已完成。消息和子程序调用之间的根本区别在于：消息被发送到数据对象，特别是为该对象定义的方法之一。然后执行被调用的方法，通常会修改消息发送到的对象的数据；子程序调用是向子程序代码发送的消息。通常，子程序要处理的数据作为参数发送给它。13

The Smalltalk world is populated by nothing but objects, from integer constants to large complex software systems. All computing in Smalltalk is done by the same uniform technique: sending a message to an object to invoke one of its methods. A reply to a message is an object, which either returns the requested information or simply notifies the sender that the requested processing has been completed. The fundamental difference between a message and a subprogram call is this: A message is sent to a data object, specifically to one of the methods defined for the object. The called method is then executed, often modifying the data of the object to which the message was sent; a subprogram call is a message to the code of a subprogram. Usually the data to be processed by the subprogram is sent to it as a parameter.13

在 Smalltalk 中，对象抽象是类，它们与 SIMULA 67 的类非常相似。可以创建类的实例，然后将其作为程序的对象。

In Smalltalk, object abstractions are classes, which are very similar to the classes of SIMULA 67. Instances of the class can be created and are then the objects of the program.

Smalltalk 的语法与大多数其他编程语言的语法不同，很大程度上是因为使用消息，而不是算术和逻辑表达式以及常规控制语句。下一小节的示例说明了 Smalltalk 控制结构之一。

The syntax of Smalltalk is unlike that of most other programming language, in large part because of the use of messages, rather than arithmetic and logic expressions and conventional control statements. One of the Smalltalk control constructs is illustrated in the example in the next subsection.

Smalltalk 为推动计算的两个不同方面做出了巨大贡献：图形用户界面和面向对象编程。窗口系统现在是用户界面的主导方法。软件系统的设计源于 Smalltalk。如今，最重要的软件设计方法和编程语言都是面向对象的。尽管面向对象语言的一些思想起源于 SIMULA 67，但它们在 Smalltalk 中达到了成熟。显然，Smalltalk 对计算世界的影响是广泛的，并将持续很长时间。

Smalltalk has done a great deal to promote two separate aspects of computing: graphical user interfaces and object-oriented programming. The windowing systems that are now the dominant method of user interfaces to software systems grew out of Smalltalk. Today, the most significant software design methodologies and programming languages are object oriented. Although the origin of some of the ideas of object-oriented languages came from SIMULA 67, they reached maturation in Smalltalk. It is clear that Smalltalk’s impact on the computing world is extensive and will be long-lived.

以下是 Smalltalk 类定义的一个例子：

The following is an example of a Smalltalk class definition:

"Smalltalk Example Program"
"The following is a class definition, instantiations of which can draw equilateral polygons of any number of sides"
class name                   Polygon
superclass                   Object
instance variable names      ourPen
numSides
sideLength
"Class methods"
  "Create an instance"
  new
     ^ super new getPen
  "Get a pen for drawing polygons"
  getPen
     ourPen <- Pen new defaultNib: 2
  "Instance methods"
  "Draw a polygon"
  draw
     numSides timesRepeat: [ourPen go: sideLength;
                             turn: 360 // numSides]

  "Set length of sides"
  length: len
  sideLength <- len

  "Set number of sides"
  sides: num
     numSides <- num

"Smalltalk Example Program"
"The following is a class definition, instantiations of which can draw equilateral polygons of any number of sides"
class name                   Polygon
superclass                   Object
instance variable names      ourPen
numSides
sideLength
"Class methods"
  "Create an instance"
  new
     ^ super new getPen
  "Get a pen for drawing polygons"
  getPen
     ourPen <- Pen new defaultNib: 2
  "Instance methods"
  "Draw a polygon"
  draw
     numSides timesRepeat: [ourPen go: sideLength;
                             turn: 360 // numSides]

  "Set length of sides"
  length: len
  sideLength <- len

  "Set number of sides"
  sides: num
     numSides <- num

1980 年，贝尔实验室的 Bjarne Stroustrup 迈出了从 C 向 C++ 迈出的第一步。对 C 的最初修改包括添加函数参数类型检查和转换，更重要的是，添加了类，这些类与 SIMULA 67 和 Smalltalk 的类相关。还包括派生类、继承组件的公有/私有访问控制、构造函数和析构函数方法以及朋友类。1981 年，添加了内联函数、默认参数和赋值运算符的重载。由此产生的语言被称为带类的 C，在Stroustrup (1983)中进行了描述。

The first step from C toward C++ was made by Bjarne Stroustrup at Bell Laboratories in 1980. The initial modifications to C included the addition of function parameter type checking and conversion and, more significantly, classes, which are related to those of SIMULA 67 and Smalltalk. Also included were derived classes, public/private access control of inherited components, constructor and destructor methods, and friend classes. During 1981, inline functions, default parameters, and overloading of the assignment operator were added. The resulting language was called C with Classes and is described in Stroustrup (1983).

考虑一下带类的 C 语言的一些目标是很有用的。主要目标是提供一种语言，在这种语言中，程序可以像在 SIMULA 67 中一样组织起来 — 即使用类和继承。第二个重要目标是，相对于 C 语言，性能损失应该很小或没有。例如，甚至没有考虑数组索引范围检查，因为与 C 语言相比，这将导致显著的性能劣势。带类的 C 语言的第三个目标是，它可以用于可以使用 C 语言的每个应用程序，因此实际上不会删除 C 语言的任何功能，即使是那些被认为不安全的功能。

It is useful to consider some goals of C with Classes. The primary goal was to provide a language in which programs could be organized as they could be organized in SIMULA 67—that is, with classes and inheritance. A second important goal was that there should be little or no performance penalty relative to C. For example, array index range checking was not even considered because a significant performance disadvantage, relative to C, would result. A third goal of C with Classes was that it could be used for every application for which C could be used, so virtually none of the features of C would be removed, not even those considered to be unsafe.

到 1984 年，该语言通过包含虚拟方法得到了扩展，虚拟方法提供了方法调用与特定方法定义、方法名称和运算符重载以及引用类型的动态绑定。该语言的这个版本被称为 C++。它在Stroustrup (1984)中进行了描述。

By 1984, this language was extended by the inclusion of virtual methods, which provide dynamic binding of method calls to specific method definitions, method name and operator overloading, and reference types. This version of the language was called C++. It is described in Stroustrup (1984).

1985 年，出现了第一个可用的实现：一个名为 Cfront 的系统，它将 C++ 程序翻译成 C 程序。这个版本的 Cfront 和它实现的 C++ 版本被命名为 Release 1.0。它在Stroustrup (1986)中进行了描述。

In 1985, the first available implementation appeared: a system named Cfront, which translated C++ programs into C programs. This version of Cfront and the version of C++ it implemented were named Release 1.0. It is described in Stroustrup (1986).

1985 年至 1989 年间，C++ 不断发展，这主要基于用户对第一个分布式实现的反应。下一个版本被命名为 Release 2.0。它的 Cfront 实现于 1989 年 6 月发布。C++ Release 2.0 中添加的最重要的特性是支持多重继承（具有多个父类的类）和抽象类，以及其他一些增强功能。第12章 介绍了抽象类。

Between 1985 and 1989, C++ continued to evolve, based largely on user reactions to the first distributed implementation. This next version was named Release 2.0. Its Cfront implementation was released in June 1989. The most important features added to C++ Release 2.0 were support for multiple inheritance (classes with more than one parent class) and abstract classes, along with some other enhancements. Abstract classes are described in Chapter 12.

C++ 3.0 版于 1989 年至 1990 年间推出。它添加了模板，提供参数化类型和异常处理。C++ 的当前版本于 1998 年标准化，在ISO (1998)中有描述。

Release 3.0 of C++ evolved between 1989 and 1990. It added templates, which provide parameterized types, and exception handling. The current version of C++, which was standardized in 1998, is described in ISO (1998).

2002 年，微软发布了 .NET 计算平台，其中包括新版本的 C++，名为托管 C++，简称 MC++。MC++ 扩展了 C++，以提供对 .NET Framework 功能的访问。新增功能包括属性、委托、接口和垃圾收集对象的引用类型。属性将在第 11章中讨论。委托将在 2.19节 的 C# 简介中简要讨论。由于 .NET 不支持多重继承，因此 MC++ 也不支持。

In 2002, Microsoft released its .NET computing platform, which included a new version of C++, named Managed C++, or MC++. MC++ extends C++ to provide access to the functionality of the .NET Framework. The additions include properties, delegates, interfaces, and a reference type for garbage-collected objects. Properties are discussed in Chapter 11. Delegates are briefly discussed in the introduction to C# in Section 2.19. Because .NET does not support multiple inheritance, neither does MC++.

由于 C++ 同时具有函数和方法，因此它同时支持过程式和面向对象编程。

Because C++ has both functions and methods, it supports both procedural and object-oriented programming.

C++ 中的运算符可以重载，这意味着用户可以为用户定义类型的现有运算符创建运算符。C++ 方法也可以重载，这意味着用户可以定义多个同名的方法，只要它们的参数数量或类型不同。

Operators in C++ can be overloaded, meaning the user can create operators for existing operators on user-defined types. C++ methods can also be overloaded, meaning the user can define more than one method with the same name, provided either the numbers or types of their parameters are different.

C++ 中的动态绑定由虚拟方法提供。这些方法使用重载方法在通过继承而关联的类集合中定义类型相关的操作。指向类 A 对象的指针也可以指向以类 A 为祖先的类的对象。当此指针指向重载虚拟方法时，将动态选择当前类型的方法。

Dynamic binding in C++ is provided by virtual methods. These methods define type-dependent operations, using overloaded methods, within a collection of classes that are related through inheritance. A pointer to an object of class A can also point to objects of classes that have class A as an ancestor. When this pointer points to an overloaded virtual method, the method of the current type is chosen dynamically.

方法和类都可以模板化，这意味着它们可以被参数化。例如，可以将方法编写为模板化方法，以允许其具有针对各种参数类型的版本。类享有同样的灵活性。

Both methods and classes can be templated, which means that they can be parameterized. For example, a method can be written as a templated method to allow it to have versions for a variety of parameter types. Classes enjoy the same flexibility.

C++ 支持多重继承。第14章 讨论了 C++ 的异常处理结构。

C++ supports multiple inheritance. The exception-handling constructs of C++ are discussed in Chapter 14.

C++ 迅速成为并一直被广泛使用的语言。其流行的一个因素是市面上有优质且价格低廉的编译器。另一个因素是它几乎完全向后兼容 C（这意味着 C 程序只需稍加改动即可编译为 C++ 程序），并且在大多数情况下，可以将 C++ 代码与 C 代码链接起来 — 因此许多 C 程序员可以相对轻松地学习 C++。最后，在 C++ 首次出现时，当面向对象编程开始受到广泛关注时，C++ 是唯一适合大型商业软件项目的可用语言。

C++ rapidly became and remains a widely used language. One factor in its popularity is the availability of good and inexpensive compilers. Another factor is that it is almost completely backward compatible with C (meaning that C programs, with few changes, can be compiled as C++ programs), and in most implementations it is possible to link C++ code with C code—and thus relatively easy for the many C programmers to learn C++. Finally, at the time C++ first appeared, when object-oriented programming began to receive widespread interest, C++ was the only available language that was suitable for large commercial software projects.

而负面的一面是，由于 C++ 是一种非常庞大和复杂的语言，它显然存在与 PL/I 类似的缺点。它继承了 C 的大部分不安全性，这使得它不如 Ada 和 Java 等语言安全。

On the negative side, because C++ is a very large and complex language, it clearly suffers drawbacks similar to those of PL/I. It inherited most of the insecurities of C, which make it less safe than languages such as Ada and Java.

从 2002 年的 MAC OS X 开始，Apple 系统软件都是用 Objective-C 编写的。Swift 是由 Apple 开发的，作为 Objective-C 的改进替代品。2010 年，Chris Lattner 开始研究 Swift。该语言于 2014 年推出，第 2 版于 2015 年推出。第一个版本是专有的，但第二个版本是开源的。它目前在 Apple 的所有操作系统以及 Linux 上都已实现。

Beginning with MAC OS X in 2002, Apple systems software was written in Objective-C. Swift was developed by Apple as an improved replacement for Objective-C. Work on Swift began in 2010 by Chris Lattner. The language was introduced in 2014, with version 2 being introduced in 2015. The first version was proprietary, but the second is open source. It is currently implemented under all of Apple’s operating systems, as well as on Linux.

Swift 的特性包括元组数据类型、选项类型（此类型的变量可以具有特殊的无值值）、协议（类似于 Java 接口）、两类类型，即类和结构体，它们支持引用类型和值类型，就像在 C# 中一样、泛型类型、无指针、更安全的 switch 构造（其中默认值是不会转到下一个选项）以及所有语句集合（包括单个语句），在所有控制构造中都必须用括号括起来。

Among the features of Swift are a tuple data type, an option type (variables of this type can have a special no-value value), protocols (similar to Java interfaces), two categories of types, class and struct, which support reference types and value types, as in C#, generic types, no pointers, a safer switch construct, in which the default is to not fall through to the next option, and all statement collections, including a single statement, must be enclosed in braces in all control constructs.

语句不需要以分号结尾，除非同一行有两个或多个语句。不需要声明数据类型，因为使用了类型推断。与 C 和 C++ 不同，赋值语句不返回值，因此x = 0在布尔表达式中使用 是不合法的。这消除了 C 和 C++ 程序中常见的错误，即 中x = 0键入的是 而不是x == 0。使用引用计数器自动回收堆分配的对象。

Statements need not be terminated with semicolons, unless there are two or more statements on the same line. Types of data need not be declared, as type inferencing is used. Unlike C and C++, assignment statements do not return a value, so using x = 0 is not legal in a Boolean expression. This eliminates a common error in C and C++ programs, in which x = 0 is typed instead of x == 0. Heap allocated objects are automatically reclaimed, using reference counters.

Swift 程序可以与 Objective-C 代码交互，并且 Swift 使用与该语言相同的库。根据 TIOBE 社区报告，Swift 已经是第十大最受欢迎的编程语言。

Swift programs can interact with Objective-C code and Swift uses the same libraries as that language. Swift is already the tenth most popular programming language, according to the TIOBE Community Report.

Delphi ( Lischner, 2000 ) 是一种混合语言，类似于 C++ 和 Objective-C，它是通过向现有的命令式语言（在本例中为 Pascal）添加面向对象支持等而创建的。Apple 设计了一个面向对象的 Pascal 版本，名为 Object Pascal，但后来放弃了该项目。曾为 Windows 开发了 Turbo Pascal 的 Borland 也设计了一个基于 Turbo Pascal 的面向对象版本的 Pascal，也名为 Object Pascal。由于多种原因，Borland 将 Object Pascal 更名为 Delphi。第一款以此名称命名的产品于 1995 年发布，其中包括一个集成开发环境 (IDE)。一些人认为 IDE 是 Delphi，底层编程语言是 Object Pascal。其他类似产品供应商继续将该语言称为 Object Pascal。

Delphi (Lischner, 2000) is a hybrid language, similar to C++ and Objective-C, in that it was created by adding object-oriented support, among other things, to an existing imperative language, in this case Pascal. Apple designed an object-oriented version of Pascal, named Object Pascal, but subsequently dropped the project. Borland, which had developed Turbo Pascal for Windows, also designed an object-oriented version of Pascal, based on Turbo Pascal, also named Object Pascal. For several reasons, Borland renamed Object Pascal as Delphi. The first product with that name, which included an integrated development environment (IDE), was released in 1995. Some consider the IDE to be Delphi and the underlying programming language to be Object Pascal. Other suppliers of similar products continue to refer to the language as Object Pascal.

C++ 和 Delphi 之间的许多差异是由其前身语言和它们所衍生的编程文化所造成的。由于 C 是一种功能强大但可能不安全的语言，因此 C++ 也符合这一描述，至少在数组下标范围检查、指针算法及其众多类型强制方面是如此。同样，由于 Pascal 比 C 更优雅、更安全，因此 Delphi 比 C++ 更优雅、更安全。Delphi 也比 C++ 简单。例如，Delphi 不包括用户定义的运算符重载、通用子程序和参数化类，而所有这些都是 C++ 的一部分。

Many of the differences between C++ and Delphi are a result of the predecessor language and the surrounding programming cultures from which they are derived. Because C is a powerful but potentially unsafe language, C++ also fits that description, at least in the areas of array subscript range checking, pointer arithmetic, and its numerous type coercions. Similarly, because Pascal is more elegant and safer than C, Delphi is more elegant and safer than C++. Delphi is also less complex than C++. For example, Delphi does not include user-defined operator overloading, generic subprograms, and parameterized classes, all of which are part of C++.

Delphi 的设计者是 Anders Hejlsberg，他之前曾开发过 Turbo Pascal 系统。Hejlsberg 于 1996 年转投微软，是 C# 的首席设计师。

Delphi was designed by Anders Hejlsberg, who had previously developed the Turbo Pascal system. Hejlsberg, who moved to Microsoft in 1996, was the lead designer of C#.

Java 与许多编程语言一样，是为一种似乎没有令人满意的现有语言的应用程序而设计的。1990 年，Sun Microsystems 确定需要一种用于嵌入式消费电子设备（如烤面包机、微波炉和交互式电视系统）的编程语言。可靠性是这种语言的主要目标之一。可靠性似乎不是微波炉软件的一个重要因素。如果烤箱的软件出现故障，它可能不会对任何人构成严重危险，而且很可能不会导致大笔法律和解。但是，如果在生产和销售了一百万台之后发现特定型号的软件有缺陷，召回将需要大量成本。因此，可靠性是消费电子产品软件的一个重要特征。

Java, like many programming languages, was designed for an application for which there appeared to be no satisfactory existing language. In 1990, Sun Microsystems determined there was a need for a programming language for embedded consumer electronic devices, such as toasters, microwave ovens, and interactive TV systems. Reliability was one of the primary goals for such a language. It may not seem that reliability would be an important factor in the software for a microwave oven. If an oven had malfunctioning software, it probably would not pose a grave danger to anyone and most likely would not lead to large legal settlements. However, if the software in a particular model was found to be erroneous after a million units had been manufactured and sold, their recall would entail significant cost. Therefore, reliability is an important characteristic of the software in consumer electronic products.

在考虑了 C 和 C++ 之后，他们认为这两种语言都不能满足开发消费电子设备软件的要求。尽管 C 语言相对较小，但它不支持面向对象编程，而他们认为面向对象编程是必需的。C++ 支持面向对象编程，但它被认为过于庞大和复杂，部分原因是它也支持面向过程编程。人们还认为 C 和 C++ 都无法提供必要的可靠性。因此，一种新的语言（后来被称为 Java）应运而生。它的设计遵循一个基本目标，即提供比 C++ 更大的简单性和可靠性。

After considering C and C++, it was decided that neither would be satisfactory for developing software for consumer electronic devices. Although C was relatively small, it did not provide support for object-oriented programming, which they deemed a necessity. C++ supported object-oriented programming, but it was judged to be too large and complex, in part because it also supported procedure-oriented programming. It was also believed that neither C nor C++ provided the necessary level of reliability. So, a new language, later named Java, was designed. Its design was guided by the fundamental goal of providing greater simplicity and reliability than C++ was believed to provide.

尽管 Java 最初的推动力是消费电子产品，但早期使用 Java 的产品从未上市销售。从 1993 年开始，当万维网开始广泛使用时，很大程度上是因为新的图形浏览器，Java 被发现是一种有用的 Web 编程工具。特别是 Java 小程序，它们是相对较小的 Java 程序，可在 Web 浏览器中解释，其输出可包含在显示的 Web 文档中，在 20 世纪 90 年代中后期迅速流行起来。在 Java 流行的最初几年里，Web 是其最常见的应用程序。

Although the initial impetus for Java was consumer electronics, none of the products with which it was used in its early years were ever marketed. Starting in 1993, when the World Wide Web became widely used, and largely because of the new graphical browsers, Java was found to be a useful tool for Web programming. In particular, Java applets, which are relatively small Java programs that are interpreted in Web browsers and whose output can be included in displayed Web documents, quickly became very popular in the middle to late 1990s. In the first few years of Java popularity, the Web was its most common application.

Java 设计团队由 James Gosling 领导，他之前曾设计过 UNIX emacs 编辑器和 NeWS 窗口系统。

The Java design team was headed by James Gosling, who had previously designed the UNIX emacs editor and the NeWS windowing system.

正如我们之前所说，Java 基于 C++，但它被专门设计为更小、更简单、更可靠。与 C++ 一样，Java 既有类，也有原始类型。Java 数组是预定义类的实例，而在 C++ 中但事实并非如此，尽管许多 C++ 用户为数组构建了包装类来添加诸如索引范围检查之类的功能，但这是 Java 中隐含的。

As we stated previously, Java is based on C++ but it was specifically designed to be smaller, simpler, and more reliable. Like C++, Java has both classes and primitive types. Java arrays are instances of a predefined class, whereas in C++ they are not, although many C++ users build wrapper classes for arrays to add features like index range checking, which is implicit in Java.

Java 没有指针，但其引用类型提供了指针的一些功能。这些引用用于指向类实例。所有对象都分配在堆上。必要时，引用总是隐式取消引用。因此它们的行为更像普通标量变量。

Java does not have pointers, but its reference types provide some of the capabilities of pointers. These references are used to point to class instances. All objects are allocated on the heap. References are always implicitly dereferenced, when necessary. So they behave more like ordinary scalar variables.

Java 有一个名为 的原始布尔类型boolean，主要用于其控制语句（例如if和while）的控制表达式。与 C 和 C++ 不同，算术表达式不能用于控制表达式。

Java has a primitive Boolean type named boolean, used mainly for the control expressions of its control statements (such as if and while). Unlike C and C++, arithmetic expressions cannot be used for control expressions.

Java 与许多支持面向对象编程的前身（包括 C++）之间的一个显著区别是，Java 中无法编写独立的子程序。所有 Java 子程序都是方法，并在类中定义。此外，方法只能通过类或对象调用。这导致的结果是，虽然 C++ 同时支持过程式和面向对象编程，但 Java 仅支持面向对象编程。

One significant difference between Java and many of its predecessors that support object-oriented programming, including C++, is that it is not possible to write stand-alone subprograms in Java. All Java subprograms are methods and are defined in classes. Furthermore, methods can be called through a class or object only. One consequence of this is that while C++ supports both procedural and object-oriented programming, Java supports object-oriented programming only.

C++ 和 Java 之间的另一个重要区别是，C++ 在其类定义中直接支持多重继承。Java 仅支持类的单次继承，尽管通过使用其接口构造可以获得多重继承的一些好处。

Another important difference between C++ and Java is that C++ supports multiple inheritance directly in its class definitions. Java supports only single inheritance of classes, although some of the benefits of multiple inheritance can be gained by using its interface construct.

未被复制到 Java 中的 C++ 构造包括结构体和联合体。

Among the C++ constructs that were not copied into Java are structs and unions.

Java 通过修饰符包含一种相对简单的并发控制形式synchronized，修饰符可以出现在方法和块上。无论哪种情况，它都会导致附加锁。锁确保互斥访问或执行。在 Java 中，创建并发进程相对容易，在 Java 中称为线程。

Java includes a relatively simple form of concurrency control through its synchronized modifier, which can appear on methods and blocks. In either case, it causes a lock to be attached. The lock ensures mutually exclusive access or execution. In Java, it is relatively easy to create concurrent processes, which in Java are called threads.

Java 对其对象使用隐式存储释放，通常称为垃圾收集。这样，程序员就无需在不再需要对象时显式删除它们。用没有垃圾收集的语言编写的程序经常会出现所谓的内存泄漏，这意味着存储被分配但从未被释放。这显然会导致所有可用存储空间最终耗尽。对象释放将在第6章 中详细讨论。

Java uses implicit storage deallocation for its objects, often called garbage collection. This frees the programmer from needing to delete objects explicitly when they are no longer needed. Programs written in languages that do not have garbage collection often suffer from what is sometimes called memory leakage, which means that storage is allocated but never deallocated. This can obviously lead to eventual depletion of all available storage. Object deallocation is discussed in detail in Chapter 6.

与 C 和 C++ 不同，Java 仅在类型扩展（从“较小”​​类型到“较大”类型）时才包含赋值类型强制（隐式类型转换）。因此，int类型float强制是通过赋值运算符完成的，而float类型int强制则不是。

Unlike C and C++, Java includes assignment type coercions (implicit type conversions) only if they are widening (from a “smaller” type to a “larger” type). So int to float coercions are done across the assignment operator, but float to int coercions are not.

Java 的设计者在削减 C++ 中多余和/或不安全的功能方面做得很好。例如，消除了 C++ 中一半的赋值强制，这显然是朝着更高可靠性迈出的一步。数组访问的索引范围检查也使该语言更安全。并发性增强了可以用该语言编写的应用程序的范围，图形用户界面、数据库访问和网络的类库也是如此。

The designers of Java did well at trimming the excess and/or unsafe features of C++. For example, the elimination of half of the assignment coercions that are done in C++ was clearly a step toward higher reliability. Index range checking of array accesses also makes the language safer. The addition of concurrency enhances the range of applications that can be written in the language, as do the class libraries for graphical user interfaces, database access, and networking.

Java 的可移植性（至少是中间形式的可移植性）通常归因于语言的设计，但事实并非如此。任何语言都可以翻译成中间形式，并在具有该中间形式虚拟机的任何平台上“运行”。这种可移植性的代价是解释成本，传统上解释成本比机器代码的执行成本高出一个数量级。Java 解释器的初始版本称为 Java 虚拟机 (JVM)，它确实比等效编译的 C 程序慢至少 10 倍。但是，现在许多 Java 程序在执行之前都会使用即时 (JIT) 编译器翻译成机器代码。这使得 Java 程序的效率与传统编译语言（如 C++）中的程序相媲美，至少在不考虑数组索引范围检查时是如此。

Java’s portability, at least in intermediate form, has often been attributed to the design of the language, but it is not. Any language can be translated to an intermediate form and “run” on any platform that has a virtual machine for that intermediate form. The price of this kind of portability is the cost of interpretation, which traditionally has been about an order of magnitude more than execution of machine code. The initial version of the Java interpreter, called the Java Virtual Machine (JVM), indeed was at least 10 times slower than equivalent compiled C programs. However, many Java programs are now translated to machine code before being executed, using Just-in-Time (JIT) compilers. This makes the efficiency of Java programs competitive with that of programs in conventionally compiled languages such as C++, at least when array index range checking is not considered.

Java 的使用增长速度比任何其他编程语言都要快。最初，这是由于它在编写动态 Web 文档方面具有很高的价值。显然，Java 迅速崛起的原因之一就是程序员喜欢它的设计。一些开发人员认为 C++ 太大太复杂，不实用也不安全。Java 为他们提供了一种替代方案，它具有 C++ 的很多功能，但语言更简单、更安全。另一个原因是 Java 的编译器/解释器系统是免费的，并且可以轻松地在 Web 上获得。Java 现在广泛应用于各种不同的应用领域。

The use of Java increased faster than that of any other programming language. Initially, this was due to its value in programming dynamic Web documents. Clearly, one of the reasons for Java’s rapid rise to prominence is simply that programmers like its design. Some developers thought C++ was too large and complex to be practical and safe. Java offered them an alternative that has much of the power of C++, but in a simpler, safer language. Another reason is that the compiler/interpreter system for Java is free and easily obtained on the Web. Java is now widely used in a variety of different applications areas.

Java 的最新版本 Java SE8 于 2014 年问世。自第一个版本以来，该语言已添加了许多重要功能。其中包括枚举类、泛型、新的迭代构造、lambda 表达式和众多类库。

The most recent version of Java, Java SE8, appeared in 2014. Since the first version, significant features have been added to the language. Among these are an enumeration class, generics, a new iteration construct, lambda expressions, and numerous class libraries.

以下是一个 Java 程序的示例：

The following is an example of a Java program:

// Java Example Program
// Input:   An integer, listlen, where listlen is less
//          than 100, followed by length-integer values
// Output:  The number of input data that are greater than
//          the average of all input values
import java.io.*;
class IntSort {
public static void main(String args[]) throws IOException {
  DataInputStream in = new DataInputStream(System.in);
  int listlen,
      counter,
      sum = 0,
      average,
      result = 0;
  int[] intlist =  new int[99];
  listlen = Integer.parseInt(in.readLine());
  if ((listlen > 0) && (listlen < 100)) {
/* Read input into an array and compute the sum */
    for (counter = 0; counter < listlen; counter++) {
      intlist[counter] =
             Integer.valueOf(in.readLine()).intValue();
      sum += intlist[counter];
    }
/* Compute the average */
    average = sum / listlen;
/* Count the input values that are > average */
    for (counter = 0; counter < listlen; counter++)
      if (intlist[counter] > average) result++;
/* Print result */
      System.out.println(
          "\nNumber of values > average is:" + result);
    } //** end of then clause of if ((listlen > 0) ... 
    else System.out.println(
             "Error-input list length is not legal\n");
  } //** end of method main
} //** end of class IntSort

// Java Example Program
// Input:   An integer, listlen, where listlen is less
//          than 100, followed by length-integer values
// Output:  The number of input data that are greater than
//          the average of all input values
import java.io.*;
class IntSort {
public static void main(String args[]) throws IOException {
  DataInputStream in = new DataInputStream(System.in);
  int listlen,
      counter,
      sum = 0,
      average,
      result = 0;
  int[] intlist =  new int[99];
  listlen = Integer.parseInt(in.readLine());
  if ((listlen > 0) && (listlen < 100)) {
/* Read input into an array and compute the sum */
    for (counter = 0; counter < listlen; counter++) {
      intlist[counter] =
             Integer.valueOf(in.readLine()).intValue();
      sum += intlist[counter];
    }
/* Compute the average */
    average = sum / listlen;
/* Count the input values that are > average */
    for (counter = 0; counter < listlen; counter++)
      if (intlist[counter] > average) result++;
/* Print result */
      System.out.println(
          "\nNumber of values > average is:" + result);
    } //** end of then clause of if ((listlen > 0) ... 
    else System.out.println(
             "Error-input list length is not legal\n");
  } //** end of method main
} //** end of class IntSort

Perl 语言由 Larry Wall 开发，最初是sh和的组合awk。Perl 自诞生以来发展迅速，现在已成为一种功能强大（尽管仍然有些原始）的编程语言。虽然它仍然经常被称为脚本语言，但它实际上更类似于典型的命令式语言，因为它总是在执行之前被编译，至少被编译成中间语言。此外，它具有所有构造，使其适用于各种计算问题领域。

The Perl language, developed by Larry Wall, was originally a combination of sh and awk. Perl has grown significantly since its beginnings and is now a powerful, although still somewhat primitive, programming language. Although it is still often called a scripting language, it is actually more similar to a typical imperative language, since it is always compiled, at least into an intermediate language, before it is executed. Furthermore, it has all the constructs to make it applicable to a wide variety of areas of computational problems.

Perl 有许多有趣的特性，本章仅提到其中的几个，并在本书后面进行讨论。

Perl has a number of interesting features, only a few of which are mentioned in this chapter and discussed later in the book.

Perl 中的变量是静态类型的，并且是隐式声明的。变量有三个不同的命名空间，由变量名称的第一个字符表示。所有标量变量名都以美元符号 ( $) 开头，所有数组名称都以 at 符号 ( @) 开头，所有哈希名称（哈希将在下文简要介绍）都以百分号 ( %) 开头。这种约定使程序中的变量名比大多数其他编程语言的变量名更具可读性。

Variables in Perl are statically typed and implicitly declared. There are three distinctive namespaces for variables, denoted by the first character of the variables’ names. All scalar variable names begin with dollar signs ($), all array names begin with at signs (@), and all hash names (hashes are briefly described below) begin with percent signs (%). This convention makes variable names in programs more readable than those of most other programming languages.

Perl 包含大量隐式变量。其中一些用于存储 Perl 参数，例如实现中使用的特定形式的换行符或字符。隐式变量通常用作内置函数的默认参数和某些运算符的默认操作数。隐式变量具有独特（尽管隐晦）的名称，例如$!和@_。隐式变量的名称与用户定义的变量名称一样，使用三个命名空间，$!标量变量的名称也是如此。

Perl includes a large number of implicit variables. Some of them are used to store Perl parameters, such as the particular form of newline character or characters that are used in the implementation. Implicit variables are commonly used as default parameters to built-in functions and default operands for some operators. The implicit variables have distinctive—although cryptic—names, such as $! and @_. The implicit variables’ names, like the user-defined variable names, use the three namespaces, so $! is the name of a scalar variable.

Perl 的数组有两个特点，使它们有别于常见命令式语言的数组。首先，它们的长度是动态的，这意味着它们可以在执行过程中根据需要增长和缩小。其次，数组可以是稀疏的，这意味着元素之间可以有间隙。这些间隙不占用内存空间，用于数组的迭代语句foreach会迭代缺失的元素。

Perl’s arrays have two characteristics that set them apart from the arrays of the common imperative languages. First, they have dynamic length, meaning that they can grow and shrink as needed during execution. Second, arrays can be sparse, meaning that there can be gaps between the elements. These gaps do not take space in memory, and the iteration statement used for arrays, foreach, iterates over the missing elements.

Perl 包含关联数组，称为哈希表。这些数据结构由字符串索引，是隐式控制的哈希表。Perl 系统提供哈希函数并在必要时增加结构的大小。

Perl includes associative arrays, which are called hashes. These data structures are indexed by strings and are implicitly controlled hash tables. The Perl system supplies the hash function and increases the size of the structure when necessary.

Perl 是一种功能强大但有点危险的语言。它的标量类型同时存储字符串和数字，通常以双精度浮点形式存储。根据上下文，数字可能会被强制转换为字符串，反之亦然。如果在数字上下文中使用字符串并且无法将该字符串转换为数字，则将使用零，并且不会向用户提供警告或错误消息。这可能导致编译器或运行时系统无法检测到的错误。无法检查数组索引，因为任何数组都没有设置下标范围。对不存在元素的引用将返回undef，在数字上下文中被解释为零。因此，在数组元素访问中也没有错误检测。

Perl is a powerful, but somewhat dangerous, language. Its scalar type stores both strings and numbers, which are normally stored in double-precision floating-point form. Depending on the context, numbers may be coerced to strings and vice versa. If a string is used in numeric context and the string cannot be converted to a number, zero is used and there is no warning or error message provided for the user. This can lead to errors that are not detected by the compiler or run-time system. Array indexing cannot be checked, because there is no set subscript range for any array. References to nonexistent elements return undef, which is interpreted as zero in numeric context. So, there is also no error detection in array element access.

Perl 最初是作为处理文本文件的 UNIX 实用程序使用的。它曾经是并且现在仍被广泛用作 UNIX 系统管理工具。当万维网出现时，Perl 被广泛用作 Web 的通用网关接口语言，尽管现在很少用于此目的。Perl 被用作各种应用的通用语言，例如计算生物学和人工智能。

Perl’s initial use was as a UNIX utility for processing text files. It was and still is widely used as a UNIX system administration tool. When the World Wide Web appeared, Perl achieved widespread use as a common gateway interface language for use with the Web, although it is now rarely used for that purpose. Perl is used as a general-purpose language for a variety of applications, such as computational biology and artificial intelligence.

以下是一个 Perl 程序的示例：

The following is an example of a Perl program:

# Perl Example Program
# Input:   An integer, $listlen, where $listlen is less
#          than 100, followed by $listlen-integer values.
# Output:  The number of input values that are greater than
#          the average of all input values.
($sum, $result) = (0, 0);
$listlen = <STDIN>;
if (($listlen > 0) && ($listlen < 100)) {
# Read input into an array and compute the sum
  for ($counter = 0; $counter < $listlen; $counter++) {
    $intlist[$counter] = <STDIN>;
  } #- end of for (counter ... 
# Compute the average
  $average = $sum / $listlen;
# Count the input values that are > average
  foreach  $num (@intlist) {
    if ($num > $average) { $result++; }
  } #- end of foreach $num ... 
# Print result
  print "Number of values > average is: $result \n";
} #- end of if (($listlen ... 
else {
  print "Error--input list length is not legal \n";
}

# Perl Example Program
# Input:   An integer, $listlen, where $listlen is less
#          than 100, followed by $listlen-integer values.
# Output:  The number of input values that are greater than
#          the average of all input values.
($sum, $result) = (0, 0);
$listlen = <STDIN>;
if (($listlen > 0) && ($listlen < 100)) {
# Read input into an array and compute the sum
  for ($counter = 0; $counter < $listlen; $counter++) {
    $intlist[$counter] = <STDIN>;
  } #- end of for (counter ... 
# Compute the average
  $average = $sum / $listlen;
# Count the input values that are > average
  foreach  $num (@intlist) {
    if ($num > $average) { $result++; }
  } #- end of foreach $num ... 
# Print result
  print "Number of values > average is: $result \n";
} #- end of if (($listlen ... 
else {
  print "Error--input list length is not legal \n";
}

20 世纪 90 年代中期，随着第一批图形浏览器的出现，网络的使用量呈爆炸式增长。HTML 文档本身是完全静态的，因此对计算的需求很快变得至关重要。通用网关接口 (CGI) 使服务器端的计算成为可能，它允许 HTML 文档请求执行服务器上的程序，并将此类计算的结果以 HTML 文档的形式返回给浏览器。随着 Java 小程序的出现，浏览器端的计算也变得可用。这两种方法现在大部分已被较新的技术（主要是脚本语言）所取代。

Use of the Web exploded in the mid-1990s after the first graphical browsers appeared. The need for computation associated with HTML documents, which by themselves are completely static, quickly became critical. Computation on the server side was made possible with the common gateway interface (CGI), which allowed HTML documents to request the execution of programs on the server, with the results of such computations returned to the browser in the form of HTML documents. Computation on the browser end became available with the advent of Java applets. Both of these approaches have now been replaced for the most part by newer technologies, primarily scripting languages.

JavaScript 最初由 Brendan Eich 在 Netscape 开发。它的原名是 Mocha。后来改名为 LiveScript。1995 年底，LiveScript 成为 Netscape 和 Sun Microsystems 的合资企业，并更名为 JavaScript。JavaScript 经历了广泛的演变，从 1.0 版发展到 1.5 版，增加了许多新特性和功能。欧洲计算机制造商协会 (ECMA) 于 20 世纪 90 年代末制定了 JavaScript 的语言标准 ECMA-262。该标准还被国际标准组织 (ISO) 批准为 ISO-16262。Microsoft 版本的 JavaScript 名为 JScript .NET。

JavaScript was originally developed by Brendan Eich at Netscape. Its original name was Mocha. It was later renamed LiveScript. In late 1995, LiveScript became a joint venture of Netscape and Sun Microsystems and its name was changed to JavaScript. JavaScript has gone through extensive evolution, moving from version 1.0 to version 1.5 by adding many new features and capabilities. A language standard for JavaScript was developed in the late 1990s by the European Computer Manufacturers Association (ECMA) as ECMA-262. This standard has also been approved by the International Standards Organization (ISO) as ISO-16262. Microsoft’s version of JavaScript is named JScript .NET.

尽管 JavaScript 解释器可以嵌入到许多不同的应用程序中，但其最常见的用途是嵌入到 Web 浏览器中。JavaScript代码嵌入 HTML 文档中，并在显示文档时由浏览器解释。JavaScript 在 Web 编程中的主要用途是验证表单输入数据和创建动态 HTML 文档。

Although a JavaScript interpreter could be embedded in many different applications, its most common use is embedded in Web browsers. JavaScript code is embedded in HTML documents and interpreted by the browser when the documents are displayed. The primary uses of JavaScript in Web programming are to validate form input data and create dynamic HTML documents.

尽管 JavaScript 的名字与 Java 相似，但它与 Java 之间唯一的联系就是语法相似。Java 是强类型的，而 JavaScript 是动态类型的（参见第5章 ）。JavaScript 的字符串及其数组的长度都是动态的。因此，JavaScript 不会检查数组索引的有效性，尽管 Java 要求这样做。Java 完全支持面向对象编程，但 JavaScript 既不支持继承，也不支持方法调用与方法的动态绑定。

In spite of its name, JavaScript is related to Java only through the use of similar syntax. Java is strongly typed, but JavaScript is dynamically typed (see Chapter 5). JavaScript’s character strings and its arrays have dynamic length. Because of this, array indices are not checked for validity, although this is required in Java. Java fully supports object-oriented programming, but JavaScript supports neither inheritance nor dynamic binding of method calls to methods.

JavaScript 最重要的用途之一是动态创建和修改 HTML 文档。JavaScript 定义了一个与 HTML 文档的层次模型相匹配的对象层次结构，该层次结构由文档对象模型定义。HTML 文档的元素通过这些对象访问，为动态控制文档元素提供了基础。

One of the most important uses of JavaScript is for dynamically creating and modifying HTML documents. JavaScript defines an object hierarchy that matches a hierarchical model of an HTML document, which is defined by the Document Object Model. Elements of an HTML document are accessed through these objects, providing the basis for dynamic control of the elements of documents.

以下是本章中用几种语言解决的问题的 JavaScript 脚本。请注意，假定此脚本将从 HTML 文档调用并由 Web 浏览器解释。

Following is a JavaScript script for the problem previously solved in several languages in this chapter. Note that it is assumed that this script will be called from an HTML document and interpreted by a Web browser.

// example.js
//   Input:  An integer, listLen, where listLen is less
//           than 100, followed by listLen-numeric values
// Output:   The number of input values that are greater
//           than the average of all input values

var intList = new Array(99);
var listLen, counter, sum = 0, result = 0;

listLen = prompt (
        "Please type the length of the input list", "");
if ((listLen > 0) && (listLen < 100)) {

// Get the input and compute its sum
   for (counter = 0; counter < listLen; counter++) {
        intList[counter] = prompt (
                        "Please type the next number", "");
        sum += parseInt(intList[counter]);
   }

// Compute the average
   average = sum / listLen;

// Count the input values that are > average
   for (counter = 0; counter < listLen; counter++)
       if (intList[counter] > average) result++;
// Display the results
   document.write("Number of values > average is: ",
                 result, "<br />");

}  else
    document.write(
       "Error - input list length is not legal <br />");

// example.js
//   Input:  An integer, listLen, where listLen is less
//           than 100, followed by listLen-numeric values
// Output:   The number of input values that are greater
//           than the average of all input values

var intList = new Array(99);
var listLen, counter, sum = 0, result = 0;

listLen = prompt (
        "Please type the length of the input list", "");
if ((listLen > 0) && (listLen < 100)) {

// Get the input and compute its sum
   for (counter = 0; counter < listLen; counter++) {
        intList[counter] = prompt (
                        "Please type the next number", "");
        sum += parseInt(intList[counter]);
   }

// Compute the average
   average = sum / listLen;

// Count the input values that are > average
   for (counter = 0; counter < listLen; counter++)
       if (intList[counter] > average) result++;
// Display the results
   document.write("Number of values > average is: ",
                 result, "<br />");

}  else
    document.write(
       "Error - input list length is not legal <br />");

PHP（Tatroe 等，2013）由 Apache 集团员工 Rasmus Lerdorf 于 1994 年开发。他最初的动机是提供一种工具来帮助追踪其个人网站的访问者。1995 年，他开发了一个名为 Personal Home Page Tools 的软件包，该软件包成为 PHP 的第一个公开发行版本。最初，PHP 是 Personal Home Page 的缩写。后来，其用户社区开始使用递归名称 PHP：超文本预处理器，这随后迫使原始名称变得晦涩难懂。PHP 现在作为开源产品进行开发、分发和支持。PHP 处理器驻留在大多数 Web 服务器上。

PHP (Tatroe et al., 2013) was developed by Rasmus Lerdorf, an employee of the Apache Group, in 1994. His initial motivation was to provide a tool to help track visitors to his personal Web site. In 1995, he developed a package called Personal Home Page Tools, which became the first publicly distributed version of PHP. Originally, PHP was an abbreviation for Personal Home Page. Later, its user community began using the recursive name PHP: Hypertext Preprocessor, which subsequently forced the original name into obscurity. PHP is now developed, distributed, and supported as an open-source product. PHP processors are resident on most Web servers.

PHP 是一种嵌入 HTML 的服务器端脚本语言，专为 Web 应用程序而设计。当浏览器请求嵌入 PHP 代码的 HTML 文档时，Web 服务器上会解释 PHP 代码。PHP 代码通常会生成 HTML 代码作为输出，以替换 HTML 文档中的 PHP 代码。因此，Web 浏览器永远不会看到 PHP 代码。

PHP is an HTML-embedded server-side scripting language specifically designed for Web applications. PHP code is interpreted on the Web server when an HTML document in which it is embedded has been requested by a browser. PHP code usually produces HTML code as output, which replaces the PHP code in the HTML document. Therefore, a Web browser never sees PHP code.

PHP 在语法外观、字符串和数组的动态特性以及动态类型的使用方面与 JavaScript 相似。PHP 的数组是 JavaScript 的数组和 Perl 的哈希的组合。

PHP is similar to JavaScript in its syntactic appearance, the dynamic nature of its strings and arrays, and its use of dynamic typing. PHP’s arrays are a combination of JavaScript’s arrays and Perl’s hashes.

PHP 的原始版本不支持面向对象编程。后来，该语言添加了抽象类、接口、析构函数和类成员的访问控制。

The original version of PHP did not support object-oriented programming. Abstract classes, interfaces, destructors, and access controls for class members have since been added to the language.

PHP 允许简单地访问 HTML 表单数据，因此使用 PHP 可以轻松处理表单。PHP 支持许多不同的数据库管理系统。这使得它成为一种用于构建需要通过 Web 访问数据库的程序的有用语言。

PHP allows simple access to HTML form data, so form processing is easy with PHP. PHP provides support for many different database management systems. This makes it a useful language for building programs that need Web access to databases.

PHP 的当前版本是 7，于 2015 年发布。

The current version of PHP is 7, released in 2015.

Python ( Lutz，2013 ) 是一种面向对象的解释型脚本语言。它的最初设计者是荷兰数学中心的 Guido van Rossum，时间是 20 世纪 90 年代初。Python 软件基金会正在继续开发它。Python 的应用类型与 Perl 相同：系统管理和其他相对较小的计算任务。Python 是一个开源系统，可用于最常见的计算平台。Python 实现可在 处获得www.python.org，其中还包含有关 Python 的大量信息。

Python (Lutz, 2013) is an object-oriented interpreted scripting language. Its initial design was by Guido van Rossum at Stichting Mathematisch Centrum in the Netherlands in the early 1990s. Its development is being continued by the Python Software Foundation. Python is being used for the same kinds of applications as Perl: system administration and other relatively small computing tasks. Python is an open-source system that is available for most common computing platforms. The Python implementation is available at www.python.org, which also has extensive information regarding Python.

Python 的语法并非直接基于任何常用语言。它是经过类型检查的，但类型是动态的。Python 包含三种数据结构，而不是数组：列表、不可变列表（称为元组）和哈希（称为字典）。有一个列表方法集合，例如append、、和，以及一个字典方法集合，例如、、和。Python 还支持列表推导，它起源于Haskell语言。列表推导在第15.8节中讨论。insertremovesortkeysvaluescopyhas_key

Python’s syntax is not based directly on any commonly used language. It is type checked, but dynamically typed. Instead of arrays, Python includes three kinds of data structures: lists; immutable lists, which are called tuples; and hashes, which are called dictionaries. There is a collection of list methods, such as append, insert, remove, and sort, as well as a collection of methods for dictionaries, such as keys, values, copy, and has_key. Python also supports list comprehensions, which originated with the Haskell language. List comprehensions are discussed in Section 15.8.

Python 是面向对象的，包含 Perl 的模式匹配功能，并具有异常处理功能。垃圾收集用于回收不再需要的对象。

Python is object oriented, includes the pattern-matching capabilities of Perl, and has exception handling. Garbage collection is used to reclaim objects when they are no longer needed.

该模块提供对表单处理的支持cgi。还提供支持 cookies、网络和数据库访问的模块。

Support for form processing is provided by the cgi module. Modules that support cookies, networking, and database access are also available.

Python 支持线程并发，也支持套接字网络编程。与其他非函数式编程语言相比，它对函数式编程的支持也更多。

Python includes support for concurrency with its threads, as well as support for network programming with its sockets. It also has more support for functional programming than other nonfunctional programming languages.

Python 的一个更有趣的特性是它可由任何用户轻松扩展。支持扩展的模块可以用任何编译语言编写。扩展可以添加函数、变量和对象类型。这些扩展作为 Python 解释器的附加功能实现。

One of the more interesting features of Python is that it can be easily extended by any user. The modules that support the extensions can be written in any compiled language. Extensions can add functions, variables, and object types. These extensions are implemented as additions to the Python interpreter.

Ruby（Thomas 等，2005）由 Yukihiro Matsumoto（又名 Matz）于 20 世纪 90 年代初设计，并于 1996 年发布。自那时起，它不断发展。Ruby 的动机是其设计者对 Perl 和 Python 的不满。尽管 Perl 和 Python 都支持面向对象编程，但14 它们都不是纯粹的面向对象语言，至少在它们都具有原始（非对象）类型并且都支持函数的意义上。

Ruby (Thomas et al., 2005) was designed by Yukihiro Matsumoto (aka Matz) in the early 1990s and released in 1996. Since then it has continually evolved. The motivation for Ruby was dissatisfaction of its designer with Perl and Python. Although both Perl and Python support object-oriented programming,14 neither is a pure object-oriented language, at least in the sense that each has primitive (nonobject) types and each supports functions.

Ruby 的主要特征是它是一种纯面向对象的语言，就像 Smalltalk 一样。每个数据值都是一个对象，所有操作都是通过方法调用进行的。Ruby 中的运算符只是用于指定相应操作的方法调用的语法机制。因为它们是方法，所以可以重新定义。所有类（预定义或用户定义的）都可以被子类化。

The primary characterizing feature of Ruby is that it is a pure object-oriented language, just as is Smalltalk. Every data value is an object and all operations are via method calls. The operators in Ruby are only syntactic mechanisms to specify method calls for the corresponding operations. Because they are methods, they can be redefined. All classes, predefined or user defined, can be subclassed.

Ruby 中的类和对象都是动态的，因为可以动态地向其中添加方法。这意味着类和对象在执行期间的不同时间可以具有不同的方法集。因此，同一类的不同实例可以有不同的行为。方法、数据和常量的集合可以包含在类的定义中。

Both classes and objects in Ruby are dynamic in the sense that methods can be dynamically added to either. This means that both classes and objects can have different sets of methods at different times during execution. So, different instantiations of the same class can behave differently. Collections of methods, data, and constants can be included in the definition of a class.

Ruby 的语法与 Eiffel 和 Ada 的语法相似。无需声明变量，因为使用了动态类型。变量的作用域在其名称中指定：名称以字母开头的变量具有局部作用域；以 开头的变量@是实例变量；以 开头的变量$ 具有全局作用域。Ruby 中存在许多 Perl 的功能，包括名称很傻的隐式变量，例如$_。

The syntax of Ruby is related to that of Eiffel and Ada. There is no need to declare variables, because dynamic typing is used. The scope of a variable is specified in its name: A variable whose name begins with a letter has local scope; one that begins with @ is an instance variable; one that begins with $ has global scope. A number of features of Perl are present in Ruby, including implicit variables with silly names, such as $_.

和 Python 一样，任何用户都可以扩展和/或修改 Ruby。Ruby 在文化上很有意思，因为它是第一种在日本设计的编程语言，并在美国得到了相对广泛的应用。

As is the case with Python, any user can extend and/or modify Ruby. Ruby is culturally interesting because it is the first programming language designed in Japan that has achieved relatively widespread use in the United States.

C# 基于 C++ 和 Java，但包含一些 Delphi 和 Visual Basic 的思想。其首席设计师 Anders Hejlsberg 还设计了 Turbo Pascal 和 Delphi，这说明 C# 的 Delphi 部分遗产。

C# is based on C++ and Java but includes some ideas from Delphi and Visual Basic. Its lead designer, Anders Hejlsberg, also designed Turbo Pascal and Delphi, which explains the Delphi parts of the heritage of C#.

C# 的目的是提供一种基于组件的软件开发语言，特别是针对 .NET Framework 中的此类开发。在这种环境中，可以轻松地将各种语言的组件组合在一起形成系统。所有 .NET 语言（包括 C#、VB.NET、Managed C++、F# 和 JScript .NET）16都使用通用类型系统 (CTS)。CTS 提供了一个通用类库。这五种 .NET 语言中的所有类型都从单个类根继承。System.Object符合 CTS 规范的编译器会创建可以组合成软件系统的对象。所有 .NET 语言都被编译成同一种中间形式，即中间语言 (IL)。17但是，与 Java 不同，IL 永远不会被解释。即时编译器用于在执行 IL 之前将其转换为机器代码。

The purpose of C# is to provide a language for component-based software development, specifically for such development in the .NET Framework. In this environment, components from a variety of languages easily can be combined to form systems. All of the .NET languages, which include C#, VB.NET, Managed C++, F#, and JScript .NET,16 use the common type system (CTS). The CTS provides a common class library. All types in all five .NET languages inherit from a single class root, System.Object. Compilers that conform to the CTS specification create objects that can be combined into software systems. All .NET languages are compiled into the same intermediate form, Intermediate Language (IL).17 Unlike Java, however, the IL is never interpreted. A Just-in-Time compiler is used to translate IL into machine code before it is executed.

许多人认为，Java 相对于 C++ 最重要的进步之一在于它排除了 C++ 的一些功能。例如，C++ 支持多重继承、指针、结构、enum类型、运算符重载和 goto 语句，但 Java 不包括这些。C# 的设计者显然不同意这种全面删除功能的做法，因为除了多重继承之外，所有这些功能都已包含在 C# 中。

Many believe that one of Java’s most important advances over C++ lies in the fact that it excludes some of C++’s features. For example, C++ supports multiple inheritance, pointers, structs, enum types, operator overloading, and a goto statement, but Java includes none of these. The designers of C# obviously disagreed with this wholesale removal of features, because all of these except multiple inheritance have been included in C#.

不过，值得赞扬的是，在一些情况下，C# 版本的 C++ 特性得到了改进。例如， C# 的枚举类型比 C++ 的更安全，因为它们永远不会被隐式转换为整数。这使它们更加类型安全。结构类型发生了显著变化，产生了一个真正有用的构造，而在 C++ 中它几乎没有用处。第12章 讨论了 C# 的结构。C# 尝试改进C、C++ 和 Java 中使用的switch语句。第8章 讨论了 C# 的 switch 。

To the credit of C#’s designers, however, in several cases, the C# version of a C++ feature has been improved. For example, the enum types of C# are safer than those of C++, because they are never implicitly converted to integers. This allows them to be more type safe. The struct type was changed significantly, resulting in a truly useful construct, whereas in C++ it serves virtually no purpose. C#’s structs are discussed in Chapter 12. C# takes a stab at improving the switch statement that is used in C, C++, and Java. C#’s switch is discussed in Chapter 8.

尽管 C++ 包含函数指针，但它们也缺乏 C++ 指向变量的指针所固有的安全性。C# 包含一种新类型委托，它是面向对象且类型安全的子程序引用。委托用于实现事件处理程序、控制线程的执行和回调。18 Java 使用接口实现回调；C++ 则使用方法指针。

Although C++ includes function pointers, they share the lack of safety that is inherent in C++’s pointers to variables. C# includes a new type, delegates, which are both object-oriented and type-safe references to subprograms. Delegates are used for implementing event handlers, controlling the execution of threads, and callbacks.18 Callbacks are implemented in Java with interfaces; in C++, method pointers are used.

在 C# 中，方法可以采用可变数量的参数，只要它们都是同一类型。这是通过使用数组类型的形式参数来指定的，前面加上params保留字。

In C#, methods can take a variable number of parameters, as long as they are all the same type. This is specified by the use of a formal parameter of array type, preceded by the params reserved word.

C++ 和 Java 都使用两种不同的类型系统：一种用于基本类型，一种用于对象。除了令人困惑之外，这还导致经常需要在两个系统之间转换值 — — 例如，将基本类型值放入存储对象的集合中。C# 通过隐式装箱和拆箱操作使两个类型系统之间的值转换部分隐式化，这些操作将在第12章 中详细讨论。19

Both C++ and Java use two distinct typing systems: one for primitives and one for objects. In addition to being confusing, this leads to a frequent need to convert values between the two systems—for example, to put a primitive value into a collection that stores objects. C# makes the conversion between values of the two typing systems partially implicit through the implicit boxing and unboxing operations, which are discussed in detail in Chapter 12.19

C# 的其他特性包括矩形数组（大多数编程语言都不支持）和foreach语句（数组和集合对象的迭代器）。Perl foreach、PHP 和 Java 5.0 中也有类似的语句。此外，C# 还包含属性，这是公共数据成员的替代方案。属性被指定为具有 get 和 set 方法的数据成员，当对相关数据成员进行引用和赋值时，会隐式调用这些方法。

Among the other features of C# are rectangular arrays, which are not supported in most programming languages, and a foreach statement, which is an iterator for arrays and collection objects. A similar foreach statement is found in Perl, PHP, and Java 5.0. Also, C# includes properties, which are an alternative to public data members. Properties are specified as data members with get and set methods, which are implicitly called when references and assignments are made to the associated data members.

C# 自 2002 年首次发布以来一直在快速发展。最新版本是 C# 7.0。C# 7.0 中的新功能是元组和一种模式匹配形式。

C# has evolved continuously and quickly from its initial release in 2002. The most recent version is C# 7.0. New in C# 7.0 are tuples and a form of pattern matching.

C# 旨在成为一种通用编程语言，比 C++ 和 Java 都更胜一筹。尽管有人认为它的某些功能是倒退的，但 C# 包含一些超越其前辈的构造。它的某些功能肯定会被未来的其他编程语言采用。

C# was meant to be an improvement over both C++ and Java as a general-purpose programming language. Although it can be argued that some of its features are a step backward, C# includes some constructs that move it beyond its predecessors. Some of its features will surely be adopted by other programming languages of the future.

以下是 C# 程序的示例：

The following is an example of a C# program:

// C# Example Program
// Input:  An integer, listlen, where listlen is less than
//         100, followed by listlen-integer values.
// Output: The number of input values that are greater
//         than the average of all input values.
using System;
public class Ch2example {
  static void Main() {
    int[] intlist;
    int listlen,
        counter,
        sum = 0,
        average,
        result = 0;
    intList = new int[99];
    listlen = Int32.Parse(Console.readLine());
    if ((listlen > 0) && (listlen < 100)) {
// Read input into an array and compute the sum
      for (counter = 0; counter < listlen; counter++) {
        intList[counter] =
                       Int32.Parse(Console.readLine());
        sum += intList[counter];
      } //- end of for (counter ... 
// Compute the average
      average = sum / listlen;
// Count the input values that are > average
      foreach (int num in intList)
        if (num > average) result++;
// Print result
      Console.WriteLine(
         "Number of values > average is:" + result);
    } //- end of if ((listlen ... 
    else
      Console.WriteLine(
         "Error--input list length is not legal");
  } //- end of method Main
} //- end of class Ch2example

// C# Example Program
// Input:  An integer, listlen, where listlen is less than
//         100, followed by listlen-integer values.
// Output: The number of input values that are greater
//         than the average of all input values.
using System;
public class Ch2example {
  static void Main() {
    int[] intlist;
    int listlen,
        counter,
        sum = 0,
        average,
        result = 0;
    intList = new int[99];
    listlen = Int32.Parse(Console.readLine());
    if ((listlen > 0) && (listlen < 100)) {
// Read input into an array and compute the sum
      for (counter = 0; counter < listlen; counter++) {
        intList[counter] =
                       Int32.Parse(Console.readLine());
        sum += intList[counter];
      } //- end of for (counter ... 
// Compute the average
      average = sum / listlen;
// Count the input values that are > average
      foreach (int num in intList)
        if (num > average) result++;
// Print result
      Console.WriteLine(
         "Number of values > average is:" + result);
    } //- end of if ((listlen ... 
    else
      Console.WriteLine(
         "Error--input list length is not legal");
  } //- end of method Main
} //- end of class Ch2example

可扩展标记语言 (XML) 是一种元标记语言。这种语言用于定义标记语言。XML 派生的标记语言用于定义 XML 数据文档。尽管 XML 文档是人类可读的，但它们是由计算机处理的。这种处理有时仅包括转换为可以有效显示或打印的替代形式。在许多情况下，这种转换是转换为 HTML，可以通过 Web 浏览器显示。在其他情况下，文档中的数据会像处理其他形式的数据文件一样进行处理。

eXtensible markup language (XML) is a metamarkup language. Such a language is used to define markup languages. XML-derived markup languages are used to define XML data documents. Although XML documents are human readable, they are processed by computers. This processing sometimes consists only of transformations to alternative forms that can be effectively displayed or printed. In many cases, such transformations are to HTML, which can be displayed by a Web browser. In other cases, the data in the document is processed, just as with other forms of data files.

XML 文档到 HTML 文档的转换由另一种标记语言可扩展样式表语言转换 (XSLT) ( www.w3.org/TR/XSLT) 指定。XSLT 可以指定类似编程的操作。因此，XSLT 是一种标记-编程混合语言。XSLT 由万维网联盟 (W3C) 于 20 世纪 90 年代末定义。

The transformation of XML documents to HTML documents is specified in another markup language, eXtensible stylesheet language transformations (XSLT) (www.w3.org/TR/XSLT). XSLT can specify programming-like operations. Therefore, XSLT is a markup-programming hybrid language. XSLT was defined by the World Wide Web Consortium (W3C) in the late 1990s.

XSLT 处理器是一个程序，它将 XML 数据文档和 XSLT 文档（也是 XML 文档的形式）作为输入。在此处理过程中，使用 XSLT 文档中描述的转换将 XML 数据文档转换为另一个 XML 文档。XSLT文档通过定义模板来指定转换，模板是 XSLT 处理器可以在 XML 输入文件中找到的数据模式。与 XSLT 文档中的每个模板相关联的是其转换指令，这些指令指定在将匹配数据放入输出文档之前如何对其进行转换。因此，模板（及其相关处理）充当子程序，当 XSLT 处理器在 XML 文档的数据中找到模式匹配时“执行”它们。

An XSLT processor is a program that takes as input an XML data document and an XSLT document (which is also in the form of an XML document). In this processing, the XML data document is transformed to another XML document,20 using the transformations described in the XSLT document. The XSLT document specifies transformations by defining templates, which are data patterns that could be found by the XSLT processor in the XML input file. Associated with each template in the XSLT document are its transformation instructions, which specify how the matching data is to be transformed before being put in the output document. So, the templates (and their associated processing) act as subprograms, which are “executed” when the XSLT processor finds a pattern match in the data of the XML document.

XSLT 还具有较低级别的编程结构。例如，它包含一个循环结构，允许选择 XML 文档的重复部分。还有一个排序过程。这些较低级别的结构由 XSLT 标签指定，例如<for-each>。

XSLT also has programming constructs at a lower level. For example, a looping construct is included, which allows repeated parts of the XML document to be selected. There is also a sort process. These lower-level constructs are specified with XSLT tags, such as <for-each>.

Java 服务器页面标准标记库 (JSTL) 的“核心”部分是另一种标记编程混合语言，尽管它的形式和用途与 XSLT 不同。在讨论 JSTL 之前，有必要介绍一下 servlet 和 Java 服务器页面 (JSP) 的概念。servlet是驻留在 Web 服务器系统上并在其上执行的 Java 类的实例。Web 浏览器显示的标记文档请求执行 servlet。servlet 的输出以 HTML 文档的形式返回给请求浏览器。在 Web 服务器进程中运行的程序称为 servlet 容器，它控制 servlet 的执行。Servlet 通常用于表单处理和数据库访问。

The “core” part of the Java Server Pages Standard Tag Library (JSTL) is another markup-programming hybrid language, although its form and purpose are different from those of XSLT. Before discussing JSTL, it is necessary to introduce the ideas of servlets and Java Server Pages (JSP). A servlet is an instance of a Java class that resides on and is executed on a Web server system. The execution of a servlet is requested by a markup document being displayed by a Web browser. The servlet’s output, which is in the form of an HTML document, is returned to the requesting browser. A program that runs in the Web server process, called a servlet container, controls the execution of servlets. Servlets are commonly used for form processing and for database access.

JSP 是一组技术，旨在支持动态 Web 文档并提供 Web 文档的其他处理需求。当浏览器请求 JSP 文档（通常是 HTML 和 Java 的混合）时，驻留在 Web 服务器系统上的 JSP 处理器程序会将该文档转换为 servlet。文档的嵌入式 Java 代码被复制到 servlet。纯 HTML 被复制到 Java 打印语句中，并按原样输出。JSP 文档中的 JSTL 标记将被处理，如下一段所述。JSP 处理器生成的 servlet 由 servlet 容器运行。

JSP is a collection of technologies designed to support dynamic Web documents and provide other processing needs of Web documents. When a JSP document, which is often a mixture of HTML and Java, is requested by a browser, the JSP processor program, which resides on a Web server system, converts the document to a servlet. The document’s embedded Java code is copied to the servlet. The plain HTML is copied into Java print statements that output it as is. The JSTL markup in the JSP document is processed, as discussed in the following paragraph. The servlet produced by the JSP processor is run by the servlet container.

JSTL 定义了一组 XML 操作元素，用于控制 Web 服务器上 JSP 文档的处理。这些元素具有与 HTML 和 XML 的其他元素相同的形式。最常用的 JSTL 控制操作元素之一是if，它指定布尔表达式作为属性。21元素的内容if（开始标记 ( <if>) 和结束标记 ( </if>) 之间的文本）是 HTML 代码，只有当布尔表达式的计算结果为真时，这些代码才会包含在输出文档中。 元素if与 C/C++ 预处理器命令相关#if。JSP 容器处理 JSP 文档的 JSTL 部分的方式类似于 C/C++ 预处理器处理 C 和 C++ 程序的方式。预处理器命令是指示预处理器如何从输入文件构建输出文件的指令。同样，JSTL 控制操作元素是指示 JSP 处理器如何从 XML 输入文件构建 XML 输出文件的指令。

The JSTL defines a collection of XML action elements that control the processing of the JSP document on the Web server. These elements have the same form as other elements of HTML and XML. One of the most commonly used JSTL control action elements is if, which specifies a Boolean expression as an attribute.21 The content of the if element (the text between the opening tag (<if>) and its closing tag (</if>)) is HTML code that will be included in the output document only if the Boolean expression evaluates to true. The if element is related to the C/C++ #if preprocessor command. The JSP container processes the JSTL parts of JSP documents in a way that is similar to how the C/C++ preprocessor processes C and C++ programs. The preprocessor commands are instructions for the preprocessor to specify how the output file is to be constructed from the input file. Similarly, JSTL control action elements are instructions for the JSP processor to specify how to build the XML output file from the XML input file.

该if元素的一个常见用途是验证浏览器用户提交的表单数据。JSP 处理器可以访问表单数据，并可以使用该if元素对其进行测试以确保它是合理的数据。如果不是，则该if元素可以在输出文档中为用户插入一条错误消息。

One common use of the if element is for the validation of form data submitted by a browser user. Form data is accessible by the JSP processor and can be tested with the if element to ensure that it is sensible data. If not, the if element can insert an error message for the user in the output document.

对于多选控制，JSTL 具有choose、when和otherwise元素。JSTL 还包括一个forEach元素，它迭代集合，这些集合通常是来自客户端的表单值。该forEach元素可以包含begin、end和step属性来控制其迭代。

For multiple selection control, JSTL has choose, when, and otherwise elements. JSTL also includes a forEach element, which iterates over collections, which typically are form values from a client. The forEach element can include begin, end, and step attributes to control its iterations.

一般来说，语言可以用两种不同的方式正式定义：通过识别和通过生成（尽管这两种方式都没有为试图学习或使用编程语言的人提供实用的定义）。假设我们有一种使用字母表的语言 L $\sum$字符。要使用识别方法正式定义 L，我们需要构建一个机制 R，称为识别设备，能够读取字母表中的字符串 $\sum \text{。}$R 会指出给定的输入字符串是否在 L 中。实际上，R 会接受或拒绝给定的字符串。这些设备就像过滤器，将合法的句子与错误形成的句子区分开来。如果 R 在输入超过 $\sum \text{，}$仅当它在 L 中时才接受它，那么 R 就是 L 的描述。因为大多数有用的语言在实际应用中都是无限的，所以这似乎是一个漫长而无效的过程。然而，识别设备并不是用来列举一种语言的所有句子的——它们有不同的用途。

In general, languages can be formally defined in two distinct ways: by recognition and by generation (although neither provides a definition that is practical by itself for people trying to learn or use a programming language). Suppose we have a language L that uses an alphabet $\sum$ of characters. To define L formally using the recognition method, we would need to construct a mechanism R, called a recognition device, capable of reading strings of characters from the alphabet $\sum \text{.}$ R would indicate whether a given input string was or was not in L. In effect, R would either accept or reject the given string. Such devices are like filters, separating legal sentences from those that are incorrectly formed. If R, when fed any string of characters over $\sum \text{,}$ accepts it only if it is in L, then R is a description of L. Because most useful languages are, for all practical purposes, infinite, this might seem like a lengthy and ineffective process. Recognition devices, however, are not used to enumerate all of the sentences of a language—they have a different purpose.

编译器的语法分析部分是编译器所翻译语言的识别器。在此角色中，识别器不需要测试某个集合中的所有可能的字符串来确定每个字符串是否属于该语言。相反，它只需要确定给定的程序是否属于该语言。实际上，语法分析器确定给定的程序在语法上是否正确。语法分析器（也称为解析器）的结构将在第4章 中讨论。

The syntax analysis part of a compiler is a recognizer for the language the compiler translates. In this role, the recognizer need not test all possible strings of characters from some set to determine whether each is in the language. Rather, it need only determine whether given programs are in the language. In effect then, the syntax analyzer determines whether the given programs are syntactically correct. The structure of syntax analyzers, also known as parsers, is discussed in Chapter 4.

语言生成器是一种可用于生成语言句子的设备。我们可以将生成器想象成一个按钮，每次按下按钮都会产生一个语言句子。由于生成器按下按钮时产生的特定句子是不可预测的，因此生成器作为语言描述器似乎是一种用途有限的设备。然而，人们更喜欢某些形式的生成器而不是识别器，因为他们可以更容易地阅读和理解它们。相比之下，编译器（语言识别器）的语法检查部分对程序员来说并不是那么有用的语言描述，因为它只能在试错模式下使用。例如，要使用编译器确定特定语句的正确语法，程序员只能提交推测版本并注意编译器是否接受它。另一方面，通常可以通过将特定语句与生成器的结构进行比较来确定其语法是否正确。

A language generator is a device that can be used to generate the sentences of a language. We can think of the generator as having a button that produces a sentence of the language every time it is pushed. Because the particular sentence that is produced by a generator when its button is pushed is unpredictable, a generator seems to be a device of limited usefulness as a language descriptor. However, people prefer certain forms of generators over recognizers because they can more easily read and understand them. By contrast, the syntax-checking portion of a compiler (a language recognizer) is not as useful a language description for a programmer because it can be used only in trial-and-error mode. For example, to determine the correct syntax of a particular statement using a compiler, the programmer can only submit a speculated version and note whether the compiler accepts it. On the other hand, it is often possible to determine whether the syntax of a particular statement is correct by comparing it with the structure of the generator.

同一种语言的形式生成和识别设备之间存在着密切的联系。这是计算机科学领域的开创性发现之一，它导致了现在人们对形式语言和编译器设计理论的了解。下一节我们将回到生成器和识别器的关系。

There is a close connection between formal generation and recognition devices for the same language. This was one of the seminal discoveries in computer science, and it led to much of what is now known about formal languages and compiler design theory. We return to the relationship of generators and recognizers in the next section.

20 世纪 50 年代中后期，诺姆·乔姆斯基 (Noam Chomsky) 和约翰·巴克斯 (John Backus) 两个人在不相关的研究工作中开发了相同的语法描述形式主义，后来成为编程语言语法最广泛使用的方法。

In the middle to late 1950s, two men, Noam Chomsky and John Backus, in unrelated research efforts, developed the same syntax description formalism, which subsequently became the most widely used method for programming language syntax.

total = subtotal1 + subtotal2

total = subtotal1 + subtotal2

A = B * ( A + C )

A = B * ( A + C )

3.3.1.6分析树

3.3.1.6 Parse Trees

语法最吸引人的特征之一是，它们自然地描述了它们所定义的语言的句子的层次句法结构。这些层次结构称为解析树。例如，图 3.1中的解析树显示了前面推导的赋值语句的结构。

One of the most attractive features of grammars is that they naturally describe the hierarchical syntactic structure of the sentences of the languages they define. These hierarchical structures are called parse trees. For example, the parse tree in Figure 3.1 shows the structure of the assignment statement derived previously.

图3.1简单语句的解析树A = B * (A + C)

Figure 3.1 A parse tree for the simple statement A = B * (A + C)

图 3.1 完整替代文本

解析树的每个内部节点都标有非终结符；每个叶子节点都标有终结符。解析树的每个子树都描述句子中抽象的一个实例。

Every internal node of a parse tree is labeled with a nonterminal symbol; every leaf is labeled with a terminal symbol. Every subtree of a parse tree describes one instance of an abstraction in the sentence.

3.3.1.7歧义

3.3.1.7 Ambiguity

如果一个文法生成的句子形式有两个或多个不同的解析树，则该文法被称为具有歧义性的。考虑示例 3.3中所示的文法，它是示例 3.2中所示文法的微小变体。

A grammar that generates a sentential form for which there are two or more distinct parse trees is said to be ambiguous. Consider the grammar shown in Example 3.3, which is a minor variation of the grammar shown in Example 3.2.

例3.3简单赋值语句的歧义文法

Example 3.3 An Ambiguous Grammar for Simple Assignment Statements

• <assign> → <id> =<expr>
  
  <id> → A | B | C
  
  <expr> → <expr> +<expr>
  
      |<expr> *<expr>
  
      | (<expr> )

    |<id>

• <assign> → <id> = <expr>
  
  <id> → A | B | C
  
  <expr> → <expr> + <expr>
  
      | <expr> * <expr>
  
      | ( <expr> )

    | <id>

示例 3.3的语法具有歧义，因为句子

The grammar of Example 3.3 is ambiguous because the sentence

A = B + C * A

A = B + C * A

有两棵不同的解析树，如图3.2 所示。出现歧义的原因是，该文法指定的句法结构比例 3.2 . 此文法允许表达式的解析树在左侧和右侧同时增长，而不是只在右侧增长。

has two distinct parse trees, as shown in Figure 3.2. The ambiguity occurs because the grammar specifies slightly less syntactic structure than does the grammar of Example 3.2. Rather than allowing the parse tree of an expression to grow only on the right, this grammar allows growth on both the left and the right.

图3.2同一句话的两棵不同的解析树，A = B + C * A

Figure 3.2 Two distinct parse trees for the same sentence, A = B + C * A

图 3.2 完整替代文本

语言结构的语法歧义是一个问题，因为编译器通常根据这些结构的语法形式来确定它们的语义。具体来说，编译器通过检查其解析树来选择要为语句生成的代码。如果语言结构有多个解析树，则无法唯一地确定结构的含义。以下小节中的两个具体示例讨论了这个问题。

Syntactic ambiguity of language structures is a problem because compilers often base the semantics of those structures on their syntactic form. Specifically, the compiler chooses the code to be generated for a statement by examining its parse tree. If a language structure has more than one parse tree, then the meaning of the structure cannot be determined uniquely. This problem is discussed in two specific examples in the following subsections.

语法还有其他几个特征有时有助于确定语法是否具有歧义性。1它们包括：（1）如果语法生成一个具有多个最左派生项的句子；（2）如果语法生成一个具有多个最右派生项的句子。

There are several other characteristics of a grammar that are sometimes useful in determining whether a grammar is ambiguous.1 They include the following: (1) if the grammar generates a sentence with more than one leftmost derivation and (2) if the grammar generates a sentence with more than one rightmost derivation.

某些解析算法可能基于歧义语法。当此类解析器遇到歧义结构时，它会使用设计者提供的非语法信息来构建正确的解析树。在许多情况下，可以将歧义语法重写为无歧义的，但仍会生成所需的语言。

Some parsing algorithms can be based on ambiguous grammars. When such a parser encounters an ambiguous construct, it uses nongrammatical information provided by the designer to construct the correct parse tree. In many cases, an ambiguous grammar can be rewritten to be unambiguous but still generate the desired language.

3.3.1.8运算符优先级

3.3.1.8 Operator Precedence

当表达式包含两个不同的运算符时，例如x + y * z，一个明显的语义问题是两个运算符的求值顺序（例如，在这个表达式中是先加再乘，还是反之亦然？）。这个语义问题可以通过为运算符分配不同的优先级来回答。例如，如果*被分配了比 更高的优先级+（由语言设计者指定），则无论两个运算符在表达式中的出现顺序如何，乘法都会首先进行。

When an expression includes two different operators, for example, x + y * z, one obvious semantic issue is the order of evaluation of the two operators (for example, in this expression is it add and then multiply, or vice versa?). This semantic question can be answered by assigning different precedence levels to operators. For example, if * has been assigned higher precedence than + (by the language designer), multiplication will be done first, regardless of the order of appearance of the two operators in the expression.

如前所述，语法可以描述某种句法结构，以便可以从其解析树中确定该结构的部分含义。具体而言，算术表达式中的运算符在解析树中生成的位置较低（因此必须先求值）这一事实可用于表明其优先级高于树中较高位置生成的运算符。例如，在图 3.2的第一个解析树中，乘法运算符在树中生成的位置较低，这可能表明它优先级高于表达式中的加法运算符。然而，第二个解析树却表明情况恰恰相反。因此，看起来这两个解析树表明了相互冲突的优先级信息。

As stated previously, a grammar can describe a certain syntactic structure so that part of the meaning of the structure can be determined from its parse tree. In particular, the fact that an operator in an arithmetic expression is generated lower in the parse tree (and therefore must be evaluated first) can be used to indicate that it has precedence over an operator produced higher up in the tree. In the first parse tree of Figure 3.2, for example, the multiplication operator is generated lower in the tree, which could indicate that it has precedence over the addition operator in the expression. The second parse tree, however, indicates just the opposite. It appears, therefore, that the two parse trees indicate conflicting precedence information.

请注意，虽然示例 3.2中的语法没有歧义，但其运算符的优先顺序并非通常的顺序。在此语法中，具有多个运算符的句子的解析树（无论涉及哪些特定的运算符）都具有表达式中最右边的运算符在解析树中的最低点，而树中的其他运算符在表达式中向左移动时逐渐升高。例如，在表达式中A + B * C，*是树中最低的，表示它应该首先完成。但是，在表达式中A * B + C，+是最低的，表示它应该首先完成。

Notice that although the grammar of Example 3.2 is not ambiguous, the precedence order of its operators is not the usual one. In this grammar, a parse tree of a sentence with multiple operators, regardless of the particular operators involved, has the rightmost operator in the expression at the lowest point in the parse tree, with the other operators in the tree moving progressively higher as one moves to the left in the expression. For example, in the expression A + B * C, * is the lowest in the tree, indicating it is to be done first. However, in the expression A * B + C, + is the lowest, indicating it is to be done first.

对于我们讨论过的简单表达式，可以编写一个语法，该语法既无歧义，又指定了+和*运算符的一致优先级，而不管运算符在表达式中出现的顺序如何。正确的顺序是通过使用单独的非终结符来表示具有不同优先级的运算符的操作数来指定的。这需要额外的非终结符和一些新规则。我们可以使用三个非终结符来表示操作数，而不是使用 <expr> 作为和 的两个操作数+，*这允许语法将不同的运算符强制到解析树中的不同级别。如果 <expr> 是表达式的根符号，则+可以通过让 <expr> 直接仅生成运算符来强制将其置于解析树的顶部+，使用新的非终结符 <term> 作为 的右操作数+。接下来，我们可以定义 <term> 来生成运算*符，使用 <term> 作为左操作数，使用新的非终结符 <factor> 作为其右操作数。现在，*在解析树中的位置将始终较低，因为它距离起始符号的距离比每次推导都要远。示例3.4+中的语法就是这样一种语法。

A grammar can be written for the simple expressions we have been discussing that is both unambiguous and specifies a consistent precedence of the + and * operators, regardless of the order in which the operators appear in an expression. The correct ordering is specified by using separate nonterminal symbols to represent the operands of the operators that have different precedence. This requires additional nonterminals and some new rules. Instead of using <expr> for both operands of both + and *, we could use three nonterminals to represent operands, which allows the grammar to force different operators to different levels in the parse tree. If <expr> is the root symbol for expressions, + can be forced to the top of the parse tree by having <expr> directly generate only + operators, using the new nonterminal, <term>, as the right operand of +. Next, we can define <term> to generate * operators, using <term> as the left operand and a new nonterminal, <factor>, as its right operand. Now, * will always be lower in the parse tree, simply because it is farther from the start symbol than + in every derivation. The grammar of Example 3.4 is such a grammar.

例3.4表达式的无歧义文法

Example 3.4 An Unambiguous Grammar for Expressions

• <assign> → <id> =<expr>
  
  <id> → A | B | C
  
  <expr> → <expr> +<term>
  
      |<term>
  
  <term> → <term> *<factor>
  
      |<factor>
  
  <factor> → (<expr> )

    |<id>

• <assign> → <id> = <expr>
  
  <id> → A | B | C
  
  <expr> → <expr> + <term>
  
      | <term>
  
  <term> → <term> * <factor>
  
      | <factor>
  
  <factor> → ( <expr> )

    | <id>

示例 3.4中的语法生成与示例 3.2 和 3.3 中的语法相同的语言，但它是明确的，并且指定了乘法和加法运算符的通常优先顺序。以下句子的推导使用了示例3.4A = B + C * A的语法：

The grammar in Example 3.4 generates the same language as the grammars of Examples 3.2 and 3.3, but it is unambiguous and it specifies the usual precedence order of multiplication and addition operators. The following derivation of the sentence A = B + C * A uses the grammar of Example 3.4:

• <assign> =><id> =<expr>
  
       => A =<expr>
  
       => A =<expr> +<term>
  
       => A =<term> +<term>
  
       => A =<factor> +<term>
  
       => A =<id> +<term> <term> <term> <factor> <factor> <id>
  
       => A = B +<factor> <factor> <id>​
  
       => A = B +*

     => A = B +*

     => A = B +*

     => A = B + C *

     => A = B + C *

     => A = B + C * A

• <assign> => <id> = <expr>
  
       => A = <expr>
  
       => A = <expr> + <term>
  
       => A = <term> + <term>
  
       => A = <factor> + <term>
  
       => A = <id> + <term>
  
       => A = B + <term>
  
       => A = B + <term> * <factor>
  
       => A = B + <factor> * <factor>
  
       => A = B + <id> * <factor>
  
       => A = B + C * <factor>
  
       => A = B + C * <id>
  
       => A = B + C * A

使用示例 3.4的语法，该句子的唯一解析树如图 3.3所示。

The unique parse tree for this sentence, using the grammar of Example 3.4, is shown in Figure 3.3.

图3.3A = B + C * A使用无歧义文法的唯一解析树

Figure 3.3 The unique parse tree for A = B + C * A using an unambiguous grammar

图 3.3 完整替代文本

解析树和派生之间的联系非常紧密：两者都可以很容易地从另一个构建出来。每个具有无歧义语法的派生都有一个唯一的解析树，尽管该树可以用不同的派生来表示。例如，该句子的以下派生A = B + C * A与之前给出的同一句子的派生不同。这是一个最右派生，而前一个是最左派生。然而，这两个派生都由同一棵解析树表示。

The connection between parse trees and derivations is very close: Either can easily be constructed from the other. Every derivation with an unambiguous grammar has a unique parse tree, although that tree can be represented by different derivations. For example, the following derivation of the sentence A = B + C * A is different from the derivation of the same sentence given previously. This is a rightmost derivation, whereas the previous one is leftmost. Both of these derivations, however, are represented by the same parse tree.

• <assign> =><id> =<expr>
  
        =><id> =<expr> +<term>
  
        =><id> =<expr> +<term> *<factor>
  
        =><id> =<expr> +<term> *<id>
  
        =><id> =<expr> +<term> * A

      =><id> =<expr> +<factor> <id> <expr> * A

      =><id> <id> =<expr> +<id> <term> <id> <factor> <id> <id> <id>* A

      =>=+ C * A

      =>=+ C * A

      =>=+ C * A

      =>=+ C * A

      =>= B + C * A

      => A = B + C * A

• <assign> => <id> = <expr>
  
        => <id> = <expr> + <term>
  
        => <id> = <expr> + <term> * <factor>
  
        => <id> = <expr> + <term> * <id>
  
        => <id> = <expr> + <term> * A

      => <id> = <expr> + <factor> * A

      => <id> = <expr> + <id> * A

      => <id> = <expr> + C * A

      => <id> = <term> + C * A

      => <id> = <factor> + C * A

      => <id> = <id> + C * A

      => <id> = B + C * A

      => A = B + C * A

3.3.1.9运算符的结合性

3.3.1.9 Associativity of Operators

当表达式包含两个具有相同优先级的运算符（*与/通常一样）时（例如），A / B * C需要一条语义规则来指定哪个运算符应具有优先级。2此规则称为结合性。

When an expression includes two operators that have the same precedence (as * and / usually have)—for example, A / B * C—a semantic rule is required to specify which should have precedence.2 This rule is named associativity.

与优先级的情况一样，表达式的语法可能正确地暗示了运算符的结合性。考虑以下赋值语句的示例：

As was the case with precedence, a grammar for expressions may correctly imply operator associativity. Consider the following example of an assignment statement:

A = B + C + A

A = B + C + A

根据示例 3.4的语法定义，该句子的解析树如图 3.4所示。

The parse tree for this sentence, as defined with the grammar of Example 3.4, is shown in Figure 3.4.

图3.4A = B + C + A用于说明加法结合律的分析树

Figure 3.4 A parse tree for A = B + C + A illustrating the associativity of addition

图 3.4 完整替代文本

图 3.4的解析树显示左加法运算符低于右加法运算符。如果加法是左结合的（这是很典型的），那么这是正确的顺序。在大多数情况下，计算机中加法的结合性是无关紧要的。在数学中，加法是结合的，这意味着左结合和右结合的求值顺序是相同的。即。(A + B) + C = A + (B + C)然而，计算机中的浮点加法不一定是结合的。例如，假设浮点值存储七位精度。考虑将 11 个数字相加的问题，其中一个数字是 ${10}^7$其余十个都是 1。如果将小数（1）逐个添加到大数中，则不会对大数产生影响，因为小数出现在大数的第八位。但是，如果先将小数相加，结果加到大数上，七位精度的结果为1.000001 *${10}^7\text{。}$减法和除法不具有结合律，无论是在数学中还是在计算机中。因此，正确的结合律对于包含其中任何一个的表达式来说可能至关重要。

The parse tree of Figure 3.4 shows the left addition operator lower than the right addition operator. This is the correct order if addition is meant to be left associative, which is typical. In most cases, the associativity of addition in a computer is irrelevant. In mathematics, addition is associative, which means that left and right associative orders of evaluation mean the same thing. That is, (A + B) + C = A + (B + C). Floating-point addition in a computer, however, is not necessarily associative. For example, suppose floating-point values store seven digits of accuracy. Consider the problem of adding 11 numbers together, where one of the numbers is ${10}^7$ and the other ten are 1. If the small numbers (the 1’s) are each added to the large number, one at a time, there is no effect on that number, because the small numbers occur in the eighth digit of the large number. However, if the small numbers are first added together and the result is added to the large number, the result in seven-digit accuracy is 1.000001 * ${10}^7\text{.}$ Subtraction and division are not associative, whether in mathematics or in a computer. Therefore, correct associativity may be essential for an expression that contains either of them.

如果一条语法规则的 LHS 也出现在其 RHS 的开头，则称该规则为左递归。这种左递归指定了左结合性。例如，示例 3.4的语法规则的左递归使加法和乘法都具有左结合性。遗憾的是，左递归不允许使用一些重要的语法分析算法。当要使用其中一种算法时，必须修改语法以删除左递归。这反过来又不允许语法精确指定某些运算符是左结合的。幸运的是，即使语法没有规定，编译器也可以强制执行左结合性。

When a grammar rule has its LHS also appearing at the beginning of its RHS, the rule is said to be left recursive. This left recursion specifies left associativity. For example, the left recursion of the rules of the grammar of Example 3.4 causes it to make both addition and multiplication left associative. Unfortunately, left recursion disallows the use of some important syntax analysis algorithms. When one of these algorithms is to be used, the grammar must be modified to remove the left recursion. This, in turn, disallows the grammar from precisely specifying that certain operators are left associative. Fortunately, left associativity can be enforced by the compiler, even though the grammar does not dictate it.

在大多数提供该功能的语言中，幂运算符是右结合的。要表示右结合性，可以使用右递归。如果 LHS 出现在 RHS 的右端，则语法规则是右递归的。规则如下

In most languages that provide it, the exponentiation operator is right associative. To indicate right associativity, right recursion can be used. A grammar rule is right recursive if the LHS appears at the right end of the RHS. Rules such as

• <因子> → <**表达式>
  
      |<因子> <
  
  表达式> <表达式> → (<表达式)

   |> id

• <factor> → <exp> ** <factor>
  
      |<exp>
  
  <exp> → ( <expr> )

   |id

可用于描述指数运算作为右结合运算符。

could be used to describe exponentiation as a right-associative operator.